erdraft 0.0.0-stage → 0.0.1

package/dist/chunk-SSLBX2OF.js

@@ -0,0 +1,2162 @@
+import {
+  checkSchema,
+  columnChangeSchema,
+  columnSchema,
+  enumSchema,
+  foreignKeyName,
+  foreignKeySchema,
+  indexName,
+  indexSchema,
+  namedTable,
+  parseSchema,
+  schemaSchema,
+  tableSchema
+} from "./chunk-VSN3XJPO.js";
+
+// src/mcp/create-server.ts
+import { z as z5 } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/core/store.ts
+import { mkdir as mkdir2, readFile, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { randomUUID } from "crypto";
+import { join as join2 } from "path";
+import { z as z3 } from "zod";
+
+// src/core/operations.ts
+import { z } from "zod";
+var operationSchema = z.discriminatedUnion("op", [
+  z.object({ op: z.literal("add_table"), table: tableSchema }),
+  z.object({ op: z.literal("drop_table"), table: z.string().min(1) }),
+  z.object({
+    op: z.literal("rename_table"),
+    table: z.string().min(1),
+    to: z.string().min(1)
+  }),
+  z.object({
+    op: z.literal("add_column"),
+    table: z.string().min(1),
+    column: columnSchema
+  }),
+  z.object({
+    op: z.literal("drop_column"),
+    table: z.string().min(1),
+    column: z.string().min(1)
+  }),
+  z.object({
+    op: z.literal("alter_column"),
+    table: z.string().min(1),
+    column: z.string().min(1),
+    set: columnChangeSchema
+  }),
+  z.object({
+    op: z.literal("add_foreign_key"),
+    table: z.string().min(1),
+    foreignKey: foreignKeySchema
+  }),
+  z.object({
+    op: z.literal("drop_foreign_key"),
+    table: z.string().min(1),
+    name: z.string().min(1)
+  }),
+  z.object({
+    op: z.literal("add_index"),
+    table: z.string().min(1),
+    index: indexSchema
+  }),
+  z.object({
+    op: z.literal("drop_index"),
+    table: z.string().min(1),
+    name: z.string().min(1)
+  }),
+  z.object({
+    op: z.literal("add_check"),
+    table: z.string().min(1),
+    check: checkSchema
+  }),
+  z.object({
+    op: z.literal("drop_check"),
+    table: z.string().min(1),
+    name: z.string().min(1)
+  }),
+  z.object({ op: z.literal("add_enum"), enum: enumSchema }),
+  z.object({
+    op: z.literal("set_enum_values"),
+    enum: z.string().min(1),
+    values: z.array(z.string().min(1)).min(1)
+  }),
+  z.object({ op: z.literal("drop_enum"), enum: z.string().min(1) })
+]);
+
+// src/core/apply-operations.ts
+var DraftError = class extends Error {
+  constructor(step, message) {
+    super(`Step ${step}: ${message}`);
+    this.step = step;
+    this.name = "DraftError";
+  }
+  step;
+};
+function tableIn(schema, name, step) {
+  const table = schema.tables.find((each) => each.name === name);
+  if (!table) {
+    throw new DraftError(step, `there is no table "${name}"`);
+  }
+  return table;
+}
+function columnIn(table, name, step) {
+  const column = table.columns.find((each) => each.name === name);
+  if (!column) {
+    throw new DraftError(
+      step,
+      `there is no column "${name}" in "${table.name}"`
+    );
+  }
+  return column;
+}
+function enumIn(schema, name, step) {
+  const found = schema.enums.find((each) => each.name === name);
+  if (!found) {
+    throw new DraftError(step, `there is no enum "${name}"`);
+  }
+  return found;
+}
+function refuseTaken(taken, what, step) {
+  if (taken) {
+    throw new DraftError(step, `${what} already exists`);
+  }
+}
+function changedColumn(column, set) {
+  const { default: defaultValue, note, shape, ...rest } = set;
+  return {
+    ...column,
+    ...rest,
+    default: defaultValue === void 0 ? column.default : defaultValue ?? void 0,
+    note: note === void 0 ? column.note : note ?? void 0,
+    shape: shape === void 0 ? column.shape : shape ?? void 0
+  };
+}
+function rename(map, from, to) {
+  const original = map[from] ?? from;
+  delete map[from];
+  map[to] = original;
+}
+function apply(schema, renames, operation, step) {
+  switch (operation.op) {
+    case "add_table": {
+      const table = namedTable(operation.table);
+      refuseTaken(
+        schema.tables.some((each) => each.name === table.name),
+        `The table "${table.name}"`,
+        step
+      );
+      for (const foreignKey of table.foreignKeys) {
+        checkForeignKey(schema, table, foreignKey, step);
+      }
+      for (const [at, index] of table.indexes.entries()) {
+        checkIndex(table, index, step, table.indexes.slice(0, at));
+      }
+      for (const [at, check] of table.checks.entries()) {
+        refuseTaken(
+          table.checks.slice(0, at).some((each) => each.name === check.name),
+          `The check "${check.name}"`,
+          step
+        );
+      }
+      schema.tables.push(table);
+      return;
+    }
+    case "drop_table": {
+      tableIn(schema, operation.table, step);
+      schema.tables = schema.tables.filter(
+        (each) => each.name !== operation.table
+      );
+      for (const table of schema.tables) {
+        table.foreignKeys = table.foreignKeys.filter(
+          (foreignKey) => foreignKey.table !== operation.table
+        );
+      }
+      delete renames.columns[operation.table];
+      delete renames.tables[operation.table];
+      return;
+    }
+    case "rename_table": {
+      const table = tableIn(schema, operation.table, step);
+      refuseTaken(
+        schema.tables.some((each) => each.name === operation.to),
+        `The table "${operation.to}"`,
+        step
+      );
+      table.name = operation.to;
+      for (const each of schema.tables) {
+        for (const foreignKey of each.foreignKeys) {
+          if (foreignKey.table === operation.table) {
+            foreignKey.table = operation.to;
+          }
+        }
+      }
+      rename(renames.tables, operation.table, operation.to);
+      const columns = renames.columns[operation.table];
+      if (columns) {
+        delete renames.columns[operation.table];
+        renames.columns[operation.to] = columns;
+      }
+      return;
+    }
+    case "add_column": {
+      const table = tableIn(schema, operation.table, step);
+      refuseTaken(
+        table.columns.some((each) => each.name === operation.column.name),
+        `The column "${operation.column.name}" in "${table.name}"`,
+        step
+      );
+      table.columns.push(operation.column);
+      return;
+    }
+    case "drop_column": {
+      const table = tableIn(schema, operation.table, step);
+      columnIn(table, operation.column, step);
+      table.columns = table.columns.filter(
+        (each) => each.name !== operation.column
+      );
+      table.foreignKeys = table.foreignKeys.filter(
+        (foreignKey) => !foreignKey.columns.includes(operation.column)
+      );
+      table.indexes = table.indexes.filter(
+        (index) => !index.columns.includes(operation.column)
+      );
+      for (const each of schema.tables) {
+        each.foreignKeys = each.foreignKeys.filter(
+          (foreignKey) => foreignKey.table !== table.name || !foreignKey.foreignColumns.includes(operation.column)
+        );
+      }
+      delete renames.columns[table.name]?.[operation.column];
+      return;
+    }
+    case "alter_column": {
+      const table = tableIn(schema, operation.table, step);
+      const column = columnIn(table, operation.column, step);
+      const to = operation.set.name;
+      if (to !== void 0 && to !== column.name) {
+        refuseTaken(
+          table.columns.some((each) => each.name === to),
+          `The column "${to}" in "${table.name}"`,
+          step
+        );
+        const swap = (name) => name === column.name ? to : name;
+        for (const foreignKey of table.foreignKeys) {
+          foreignKey.columns = foreignKey.columns.map(swap);
+        }
+        for (const index of table.indexes) {
+          index.columns = index.columns.map(swap);
+        }
+        for (const each of schema.tables) {
+          for (const foreignKey of each.foreignKeys) {
+            if (foreignKey.table === table.name) {
+              foreignKey.foreignColumns = foreignKey.foreignColumns.map(swap);
+            }
+          }
+        }
+        const columns = renames.columns[table.name] ?? {};
+        renames.columns[table.name] = columns;
+        rename(columns, column.name, to);
+      }
+      table.columns = table.columns.map(
+        (each) => each === column ? changedColumn(column, operation.set) : each
+      );
+      return;
+    }
+    case "add_foreign_key": {
+      const table = tableIn(schema, operation.table, step);
+      const foreignKey = {
+        ...operation.foreignKey,
+        name: foreignKeyName(table.name, operation.foreignKey)
+      };
+      refuseTaken(
+        table.foreignKeys.some((each) => each.name === foreignKey.name),
+        `The foreign key "${foreignKey.name}"`,
+        step
+      );
+      checkForeignKey(schema, table, foreignKey, step);
+      table.foreignKeys.push(foreignKey);
+      return;
+    }
+    case "drop_foreign_key": {
+      const table = tableIn(schema, operation.table, step);
+      if (!table.foreignKeys.some((each) => each.name === operation.name)) {
+        throw new DraftError(
+          step,
+          `there is no foreign key "${operation.name}" in "${table.name}"`
+        );
+      }
+      table.foreignKeys = table.foreignKeys.filter(
+        (each) => each.name !== operation.name
+      );
+      return;
+    }
+    case "add_index": {
+      const table = tableIn(schema, operation.table, step);
+      const index = {
+        ...operation.index,
+        name: indexName(table.name, operation.index)
+      };
+      checkIndex(table, index, step, table.indexes);
+      table.indexes.push(index);
+      return;
+    }
+    case "drop_index": {
+      const table = tableIn(schema, operation.table, step);
+      if (!table.indexes.some((each) => each.name === operation.name)) {
+        throw new DraftError(
+          step,
+          `there is no index "${operation.name}" in "${table.name}"`
+        );
+      }
+      table.indexes = table.indexes.filter(
+        (each) => each.name !== operation.name
+      );
+      return;
+    }
+    case "add_check": {
+      const table = tableIn(schema, operation.table, step);
+      refuseTaken(
+        table.checks.some((each) => each.name === operation.check.name),
+        `The check "${operation.check.name}"`,
+        step
+      );
+      table.checks.push(operation.check);
+      return;
+    }
+    case "drop_check": {
+      const table = tableIn(schema, operation.table, step);
+      if (!table.checks.some((each) => each.name === operation.name)) {
+        throw new DraftError(
+          step,
+          `there is no check "${operation.name}" in "${table.name}"`
+        );
+      }
+      table.checks = table.checks.filter((each) => each.name !== operation.name);
+      return;
+    }
+    case "add_enum": {
+      refuseTaken(
+        schema.enums.some((each) => each.name === operation.enum.name),
+        `The enum "${operation.enum.name}"`,
+        step
+      );
+      schema.enums.push(operation.enum);
+      return;
+    }
+    case "set_enum_values": {
+      enumIn(schema, operation.enum, step).values = operation.values;
+      return;
+    }
+    case "drop_enum": {
+      enumIn(schema, operation.enum, step);
+      schema.enums = schema.enums.filter((each) => each.name !== operation.enum);
+      return;
+    }
+  }
+}
+function checkForeignKey(schema, table, foreignKey, step) {
+  for (const name of foreignKey.columns) {
+    columnIn(table, name, step);
+  }
+  const target = foreignKey.table === table.name ? table : tableIn(schema, foreignKey.table, step);
+  for (const name of foreignKey.foreignColumns) {
+    columnIn(target, name, step);
+  }
+  if (foreignKey.columns.length !== foreignKey.foreignColumns.length) {
+    throw new DraftError(
+      step,
+      `the foreign key "${foreignKey.name}" has ${foreignKey.columns.length} columns and points to ${foreignKey.foreignColumns.length}`
+    );
+  }
+}
+function checkIndex(table, index, step, before) {
+  refuseTaken(
+    before.some((each) => each.name === index.name),
+    `The index "${index.name}"`,
+    step
+  );
+  for (const name of index.columns) {
+    columnIn(table, name, step);
+  }
+}
+function applyOperations(base, operations2) {
+  const schema = structuredClone(base);
+  const renames = { tables: {}, columns: {} };
+  for (const [index, operation] of structuredClone(operations2).entries()) {
+    apply(schema, renames, operation, index + 1);
+  }
+  return { schema, renames };
+}
+
+// src/core/fields.ts
+import { z as z2 } from "zod";
+var STORAGE_AREAS = ["local", "session"];
+var destinationSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("column"),
+    table: z2.string(),
+    column: z2.string()
+  }),
+  z2.object({
+    kind: z2.literal("storage"),
+    area: z2.enum(STORAGE_AREAS),
+    key: z2.string()
+  }),
+  z2.object({ kind: z2.literal("none") })
+]);
+var fieldSchema = z2.object({
+  page: z2.string().min(1),
+  label: z2.string().min(1),
+  destination: destinationSchema,
+  tracedAt: z2.string()
+});
+function describeDestination(destination) {
+  if (destination.kind === "column") {
+    return `${destination.table}.${destination.column}`;
+  }
+  if (destination.kind === "storage") {
+    return `${destination.area}Storage "${destination.key}"`;
+  }
+  return "kept nowhere since it changed: not saved yet, or kept on the page only";
+}
+function describeFields(fields) {
+  if (fields.length === 0) {
+    return "No field traced yet: in the project's app, in development, Erdraft's inspector (Alt+Shift+D) traces a field clicked.";
+  }
+  const pages = [...new Set(fields.map((field) => field.page))];
+  return pages.flatMap((page) => [
+    page,
+    ...fields.filter((field) => field.page === page).map(
+      (field) => `  ${field.label} \u2192 ${describeDestination(field.destination)}`
+    )
+  ]).join("\n");
+}
+
+// src/core/locked.ts
+import { mkdir, writeFile, stat, rm } from "fs/promises";
+import { join } from "path";
+var LOCK_FILE = ".lock";
+var LOCK_STEP = 20;
+var LOCK_STALE = 1e4;
+async function ageOf(path) {
+  try {
+    return Date.now() - (await stat(path)).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+async function locked(folder, change) {
+  const path = join(folder, LOCK_FILE);
+  await mkdir(folder, { recursive: true });
+  for (; ; ) {
+    try {
+      await writeFile(path, String(process.pid), { flag: "wx" });
+      break;
+    } catch (error) {
+      const held = error instanceof Error && "code" in error && error.code === "EEXIST";
+      if (!held) {
+        throw error;
+      }
+      if (await ageOf(path) > LOCK_STALE) {
+        await rm(path, { force: true });
+      } else {
+        await new Promise((done) => setTimeout(done, LOCK_STEP));
+      }
+    }
+  }
+  try {
+    return await change();
+  } finally {
+    await rm(path, { force: true });
+  }
+}
+
+// src/core/store.ts
+var DRAFT_STATUSES = ["proposed", "adopted", "discarded"];
+var DECISION_SECONDS = 30;
+var baseSchema = z3.object({
+  source: z3.string(),
+  readAt: z3.string(),
+  schema: schemaSchema
+});
+var draftSchema = z3.object({
+  id: z3.string(),
+  title: z3.string(),
+  summary: z3.string(),
+  group: z3.string().optional(),
+  status: z3.enum(DRAFT_STATUSES),
+  operations: z3.array(operationSchema),
+  createdAt: z3.string(),
+  updatedAt: z3.string()
+});
+var viewSchema = z3.object({
+  draft: z3.string().nullable().optional(),
+  table: z3.string().nullable().optional(),
+  column: z3.string().nullable().optional(),
+  related: z3.boolean().optional(),
+  at: z3.string()
+});
+var fieldsSchema = z3.array(fieldSchema);
+var placesSchema = z3.record(
+  z3.string(),
+  z3.object({ x: z3.number(), y: z3.number() })
+);
+var layoutsSchema = z3.record(z3.string(), placesSchema);
+var BASE_FILE = "base.json";
+var DRAFTS_FILE = "drafts.json";
+var VIEW_FILE = "view.json";
+var LAYOUTS_FILE = "layouts.json";
+var SEQUENCE_FILE = "sequence.json";
+var FIELDS_FILE = "fields.json";
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+function pause(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+async function writeJson(path, value) {
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  await writeFile2(temporary, `${JSON.stringify(value, null, 2)}
+`);
+  await rename2(temporary, path);
+}
+function store(folder, workspace = "default") {
+  const own = join2(folder, "workspaces", workspace);
+  const basePath = join2(own, BASE_FILE);
+  const draftsPath = join2(folder, DRAFTS_FILE);
+  const viewPath = join2(own, VIEW_FILE);
+  const layoutsPath = join2(folder, LAYOUTS_FILE);
+  const sequencePath = join2(folder, SEQUENCE_FILE);
+  const fieldsPath = join2(folder, FIELDS_FILE);
+  async function readLastNumber() {
+    const value = await readJson(sequencePath);
+    return value === void 0 ? 0 : z3.object({ last: z3.number() }).parse(value).last;
+  }
+  async function readLayouts() {
+    const value = await readJson(layoutsPath);
+    return value === void 0 ? {} : layoutsSchema.parse(value);
+  }
+  async function readAllFields() {
+    const value = await readJson(fieldsPath);
+    return value === void 0 ? [] : fieldsSchema.parse(value);
+  }
+  async function readBase() {
+    const value = await readJson(basePath);
+    if (value === void 0) {
+      return null;
+    }
+    const base = baseSchema.parse(value);
+    return { ...base, schema: parseSchema(base.schema) };
+  }
+  async function readDrafts() {
+    const value = await readJson(draftsPath);
+    return value === void 0 ? [] : z3.array(draftSchema).parse(value);
+  }
+  async function writeDrafts(drafts) {
+    await mkdir2(folder, { recursive: true });
+    await writeJson(draftsPath, drafts);
+  }
+  async function requireBase() {
+    const base = await readBase();
+    if (!base) {
+      throw new Error("The schema has not been read yet: run `erdraft read`");
+    }
+    return base;
+  }
+  function draftIn(drafts, id) {
+    const draft = drafts.find((each) => each.id === id);
+    if (!draft) {
+      throw new Error(`There is no draft "${id}"`);
+    }
+    return draft;
+  }
+  return {
+    folder,
+    async read() {
+      const view = await readJson(viewPath);
+      return {
+        base: await readBase(),
+        drafts: await readDrafts(),
+        view: view === void 0 ? null : viewSchema.parse(view),
+        layouts: await readLayouts()
+      };
+    },
+    // The cards moved where the window showed them, or none (the layout set back to the diagram's own)
+    async saveLayout(key, places) {
+      await locked(folder, async () => {
+        const layouts = await readLayouts();
+        if (Object.keys(places).length > 0) {
+          layouts[key] = places;
+        } else {
+          delete layouts[key];
+        }
+        await mkdir2(folder, { recursive: true });
+        await writeJson(layoutsPath, layouts);
+      });
+    },
+    // The window asked to show something, now
+    async show(view) {
+      const asked = { ...view, at: (/* @__PURE__ */ new Date()).toISOString() };
+      await mkdir2(own, { recursive: true });
+      await writeJson(viewPath, asked);
+      return asked;
+    },
+    // The app's fields traced, on every page, or on one
+    async readFields(page) {
+      const fields = await readAllFields();
+      return page === void 0 ? fields : fields.filter((field) => field.page === page);
+    },
+    // A field traced, in the place of what was traced of it before (its page and its label the same)
+    async saveField(field) {
+      return locked(folder, async () => {
+        const fields = await readAllFields();
+        const traced = { ...field, tracedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        const others = fields.filter(
+          (each) => each.page !== field.page || each.label !== field.label
+        );
+        await mkdir2(folder, { recursive: true });
+        await writeJson(fieldsPath, [...others, traced]);
+        return traced;
+      });
+    },
+    readBase,
+    readDrafts,
+    async writeBase(base) {
+      await mkdir2(own, { recursive: true });
+      await writeJson(basePath, base);
+    },
+    async draft(id) {
+      return draftIn(await readDrafts(), id);
+    },
+    // A draft once the person has adopted it or set it aside (adopting another of its group sets it aside too), or
+    // as it still stands when `within` milliseconds are up or the wait is called off; read again every `every`
+    async decision(id, within, every = 1e3, signal) {
+      const until = Date.now() + within;
+      for (; ; ) {
+        const draft = draftIn(await readDrafts(), id);
+        if (draft.status !== "proposed" || Date.now() >= until || signal?.aborted) {
+          return draft;
+        }
+        await pause(every, signal);
+      }
+    },
+    // A new draft, its operations applied to the base first, so one that cannot be is refused and never kept
+    async propose(input) {
+      return locked(folder, async () => {
+        const base = await requireBase();
+        const operations2 = z3.array(operationSchema).parse(input.operations);
+        applyOperations(base.schema, operations2);
+        const drafts = await readDrafts();
+        const number = Math.max(
+          await readLastNumber(),
+          ...drafts.map((each) => Number(each.id.slice(1)))
+        );
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const draft = {
+          id: `d${number + 1}`,
+          title: input.title,
+          summary: input.summary ?? "",
+          group: input.group,
+          status: "proposed",
+          operations: operations2,
+          createdAt: now,
+          updatedAt: now
+        };
+        await writeDrafts([...drafts, draft]);
+        await writeJson(sequencePath, { last: number + 1 });
+        return draft;
+      });
+    },
+    // A draft changed: its operations followed or taken over, its title, summary or group; checked on the base, and
+    // proposed again
+    async revise(id, revision) {
+      return locked(folder, async () => {
+        const base = await requireBase();
+        const drafts = await readDrafts();
+        const draft = draftIn(drafts, id);
+        const given = z3.array(operationSchema).parse(revision.operations ?? []);
+        const operations2 = revision.mode === "replace" ? given : [...draft.operations, ...given];
+        applyOperations(base.schema, operations2);
+        const next = {
+          ...draft,
+          title: revision.title ?? draft.title,
+          summary: revision.summary ?? draft.summary,
+          group: revision.group ?? draft.group,
+          operations: operations2,
+          status: "proposed",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await writeDrafts(drafts.map((each) => each.id === id ? next : each));
+        return next;
+      });
+    },
+    // A draft gone for good, and where the person left the cards of what it showed: what it was is not kept
+    async deleteDraft(id) {
+      return locked(folder, async () => {
+        const drafts = await readDrafts();
+        const draft = draftIn(drafts, id);
+        await writeDrafts(drafts.filter((each) => each.id !== id));
+        const layouts = await readLayouts();
+        const kept = Object.fromEntries(
+          Object.entries(layouts).filter(
+            ([key]) => key !== id && !key.startsWith(`${id}|`)
+          )
+        );
+        if (Object.keys(kept).length !== Object.keys(layouts).length) {
+          await writeJson(layoutsPath, kept);
+        }
+        return draft;
+      });
+    },
+    // A draft adopted or discarded; adopting one sets the others of its group still proposed aside
+    async setStatus(id, status) {
+      return locked(folder, async () => {
+        const drafts = await readDrafts();
+        const draft = draftIn(drafts, id);
+        const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const next = { ...draft, status, updatedAt };
+        const sibling = (each) => status === "adopted" && draft.group !== void 0 && each.group === draft.group && each.status === "proposed";
+        await writeDrafts(
+          drafts.map((each) => {
+            if (each.id === id) {
+              return next;
+            }
+            return sibling(each) ? { ...each, status: "discarded", updatedAt } : each;
+          })
+        );
+        return next;
+      });
+    }
+  };
+}
+
+// package.json
+var version = "0.0.1";
+
+// src/core/version.ts
+var VERSION = version;
+var version_default = VERSION;
+
+// src/core/databases.ts
+import { join as join3 } from "path";
+import { readFile as readFile2, mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+function choicePath(config) {
+  return join3(config.store, "workspaces", config.workspace, "database.json");
+}
+function storeOf(config, database) {
+  return store(join3(config.store, "databases", database.id), config.workspace);
+}
+async function currentDatabase(config) {
+  const chosen = await readFile2(choicePath(config), "utf8").then(
+    (text5) => JSON.parse(text5).id,
+    () => void 0
+  );
+  return config.databases.find((database) => database.id === chosen) ?? config.databases[0];
+}
+function databaseOf(config, id) {
+  const database = config.databases.find((each) => each.id === id);
+  if (!database) {
+    throw new Error(
+      `There is no database "${id}": ${config.databases.map((each) => each.id).join(", ")}`
+    );
+  }
+  return database;
+}
+async function chooseDatabase(config, id) {
+  const database = databaseOf(config, id);
+  await mkdir3(join3(config.store, "workspaces", config.workspace), {
+    recursive: true
+  });
+  await writeFile3(choicePath(config), `${JSON.stringify({ id })}
+`);
+  return database;
+}
+
+// src/core/read-schema.ts
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+import { extname, dirname, join as join4, relative } from "path";
+import { existsSync } from "fs";
+import { z as z4 } from "zod";
+import { fork } from "child_process";
+var TSX = pathToFileURL(createRequire(import.meta.url).resolve("tsx")).href;
+var CHILD = new URL(
+  `./read-schema-child${extname(new URL(import.meta.url).pathname)}`,
+  import.meta.url
+);
+function tsconfigOf(schema) {
+  for (let folder = dirname(schema); ; folder = dirname(folder)) {
+    const tsconfig = join4(folder, "tsconfig.json");
+    if (existsSync(tsconfig)) {
+      return tsconfig;
+    }
+    if (dirname(folder) === folder) {
+      return void 0;
+    }
+  }
+}
+var sentSchema = z4.union([
+  z4.object({ schema: z4.unknown() }),
+  z4.object({ error: z4.string() })
+]);
+function readInChild(config, schema) {
+  return new Promise((done, fail) => {
+    const tsconfig = tsconfigOf(schema);
+    const child = fork(CHILD, [schema], {
+      cwd: config.root,
+      execArgv: ["--import", TSX],
+      env: {
+        ...process.env,
+        ...tsconfig ? { TSX_TSCONFIG_PATH: tsconfig } : {}
+      },
+      stdio: ["ignore", "ignore", "inherit", "ipc"]
+    });
+    const source = relative(config.root, schema);
+    let sent;
+    child.on("message", (message) => {
+      sent = sentSchema.parse(message);
+    });
+    child.on("close", (code) => {
+      if (sent === void 0) {
+        fail(
+          new Error(
+            `${source} could not be read (its process stopped with code ${code})`
+          )
+        );
+      } else if ("error" in sent) {
+        fail(new Error(`${source} could not be read: ${sent.error}`));
+      } else {
+        done(parseSchema(sent.schema));
+      }
+    });
+  });
+}
+async function readSchema(config, database, store2) {
+  const schema = await readInChild(config, database.schema);
+  if (schema.tables.length === 0 && schema.enums.length === 0) {
+    throw new Error(
+      `${relative(config.root, database.schema)} exports no Postgres table nor enum: Erdraft reads drizzle-orm/pg-core's`
+    );
+  }
+  const base = {
+    source: relative(config.root, database.schema),
+    readAt: (/* @__PURE__ */ new Date()).toISOString(),
+    schema
+  };
+  await store2.writeBase(base);
+  return base;
+}
+
+// src/core/diff-schemas.ts
+var COLUMN_FIELDS = [
+  "type",
+  "nullable",
+  "primaryKey",
+  "unique",
+  "default",
+  "note",
+  "shape"
+];
+function byName(items) {
+  return new Map(items.map((item) => [item.name, item]));
+}
+function originalOf(name, renames) {
+  const from = renames?.[name];
+  if (from !== void 0) {
+    return from;
+  }
+  const taken = new Set(Object.values(renames ?? {}));
+  return taken.has(name) ? void 0 : name;
+}
+function invert(map) {
+  return new Map(Object.entries(map ?? {}).map(([to, from]) => [from, to]));
+}
+function signature(foreignKey) {
+  return `${foreignKey.columns.join(",")}>${foreignKey.table}.${foreignKey.foreignColumns.join(",")}`;
+}
+function indexSignature(index) {
+  return `${index.unique ? "unique" : "index"}(${index.columns.join(",")})`;
+}
+function checkSignature(check) {
+  return `${check.name}:${check.expression}`;
+}
+function diffBySignature(draft, base, signature2, said2 = signature2) {
+  const baseItems = new Map(base.map((item) => [said2(item), item]));
+  const draftItems = new Set(draft.map(signature2));
+  return [
+    ...draft.map((item) => ({
+      item,
+      status: baseItems.has(signature2(item)) ? "same" : "added"
+    })),
+    ...[...baseItems].filter(([key]) => !draftItems.has(key)).map(([, item]) => ({ item, status: "removed" }))
+  ];
+}
+function allOf(table, status) {
+  return {
+    name: table.name,
+    status,
+    note: table.note,
+    columns: table.columns.map((column) => ({
+      column,
+      status,
+      changed: []
+    })),
+    foreignKeys: table.foreignKeys.map((foreignKey) => ({
+      foreignKey,
+      status
+    })),
+    indexes: table.indexes.map((index) => ({ index, status })),
+    checks: table.checks.map((check) => ({ check, status }))
+  };
+}
+function diffColumns(draft, base, renames) {
+  const baseColumns = byName(base.columns);
+  const matched = /* @__PURE__ */ new Set();
+  const columns = draft.columns.map((column) => {
+    const original = originalOf(column.name, renames);
+    const before = original === void 0 ? void 0 : baseColumns.get(original);
+    if (!before) {
+      return { column, status: "added", changed: [] };
+    }
+    matched.add(before.name);
+    const changed = COLUMN_FIELDS.filter(
+      (field) => column[field] !== before[field]
+    );
+    const was = before.name === column.name ? void 0 : before.name;
+    return {
+      column,
+      status: changed.length > 0 || was ? "changed" : "same",
+      was,
+      changed,
+      before
+    };
+  });
+  for (const column of base.columns) {
+    if (!matched.has(column.name)) {
+      columns.push({ column, status: "removed", changed: [] });
+    }
+  }
+  return columns;
+}
+function diffSchemas(base, { schema, renames }) {
+  const baseTables = byName(base.tables);
+  const forwardTables = invert(renames.tables);
+  const newName = (table) => forwardTables.get(table) ?? table;
+  const newColumn = (table, column) => invert(renames.columns[table]).get(column) ?? column;
+  const matched = /* @__PURE__ */ new Set();
+  const tables = schema.tables.map((table) => {
+    const original = originalOf(table.name, renames.tables);
+    const before = original === void 0 ? void 0 : baseTables.get(original);
+    if (!before) {
+      return allOf(table, "added");
+    }
+    matched.add(before.name);
+    const columns = diffColumns(table, before, renames.columns[table.name]);
+    const foreignKeys = diffBySignature(
+      table.foreignKeys,
+      before.foreignKeys,
+      signature,
+      (foreignKey) => {
+        const target = newName(foreignKey.table);
+        return signature({
+          ...foreignKey,
+          columns: foreignKey.columns.map(
+            (column) => newColumn(table.name, column)
+          ),
+          table: target,
+          foreignColumns: foreignKey.foreignColumns.map(
+            (column) => newColumn(target, column)
+          )
+        });
+      }
+    ).map(({ item, status }) => ({ foreignKey: item, status }));
+    const indexes = diffBySignature(
+      table.indexes,
+      before.indexes,
+      indexSignature,
+      (index) => indexSignature({
+        ...index,
+        columns: index.columns.map((column) => newColumn(table.name, column))
+      })
+    ).map(({ item, status }) => ({ index: item, status }));
+    const checks = diffBySignature(
+      table.checks,
+      before.checks,
+      checkSignature
+    ).map(({ item, status }) => ({ check: item, status }));
+    const was = before.name === table.name ? void 0 : before.name;
+    const changed = was !== void 0 || table.note !== before.note || [...columns, ...foreignKeys, ...indexes, ...checks].some(
+      (each) => each.status !== "same"
+    );
+    return {
+      name: table.name,
+      was,
+      status: changed ? "changed" : "same",
+      note: table.note,
+      columns,
+      foreignKeys,
+      indexes,
+      checks
+    };
+  });
+  for (const table of base.tables) {
+    if (!matched.has(table.name)) {
+      tables.push(allOf(table, "removed"));
+    }
+  }
+  return { tables, enums: diffEnums(base.enums, schema.enums) };
+}
+function diffEnums(base, draft) {
+  const baseEnums = byName(base);
+  const draftNames = new Set(draft.map((each) => each.name));
+  const enums = draft.map((each) => {
+    const before = baseEnums.get(each.name);
+    if (!before) {
+      return {
+        name: each.name,
+        status: "added",
+        values: each.values.map((value) => ({ value, status: "added" }))
+      };
+    }
+    const values = [
+      ...each.values.map((value) => ({
+        value,
+        status: before.values.includes(value) ? "same" : "added"
+      })),
+      ...before.values.filter((value) => !each.values.includes(value)).map((value) => ({ value, status: "removed" }))
+    ];
+    return {
+      name: each.name,
+      status: values.some((value) => value.status !== "same") ? "changed" : "same",
+      values
+    };
+  });
+  for (const each of base) {
+    if (!draftNames.has(each.name)) {
+      enums.push({
+        name: each.name,
+        status: "removed",
+        values: each.values.map((value) => ({ value, status: "removed" }))
+      });
+    }
+  }
+  return enums;
+}
+
+// src/core/diff-draft.ts
+function diffDraft(base, operations2 = []) {
+  return diffSchemas(base, applyOperations(base, operations2));
+}
+
+// src/core/written-in.ts
+function touchedBy(operations2) {
+  const tables = /* @__PURE__ */ new Set();
+  const enums = /* @__PURE__ */ new Set();
+  for (const operation of operations2) {
+    switch (operation.op) {
+      case "add_table":
+        tables.add(operation.table.name);
+        break;
+      case "rename_table":
+        tables.add(operation.table).add(operation.to);
+        break;
+      case "add_enum":
+        enums.add(operation.enum.name);
+        break;
+      case "set_enum_values":
+      case "drop_enum":
+        enums.add(operation.enum);
+        break;
+      default:
+        tables.add(operation.table);
+    }
+  }
+  return { tables, enums };
+}
+function alreadyHolds(schema, operation) {
+  const table = schema.tables.find(
+    (each) => "table" in operation && each.name === operation.table
+  );
+  const hasColumn = (name) => table?.columns.some((each) => each.name === name) === true;
+  const named = (kind, name) => table?.[kind].some((each) => each.name === name) === true;
+  switch (operation.op) {
+    case "drop_table":
+      return table === void 0;
+    case "rename_table":
+      return table === void 0 && schema.tables.some((each) => each.name === operation.to);
+    case "add_column":
+      return hasColumn(operation.column.name);
+    case "drop_column":
+      return !hasColumn(operation.column);
+    case "alter_column":
+      return !hasColumn(operation.column) && hasColumn(operation.set.name ?? operation.column);
+    case "add_foreign_key":
+      return named(
+        "foreignKeys",
+        foreignKeyName(operation.table, operation.foreignKey)
+      );
+    case "drop_foreign_key":
+      return !named("foreignKeys", operation.name);
+    case "add_index":
+      return named("indexes", indexName(operation.table, operation.index));
+    case "drop_index":
+      return !named("indexes", operation.name);
+    case "add_check":
+      return named("checks", operation.check.name);
+    case "drop_check":
+      return !named("checks", operation.name);
+    case "drop_enum":
+      return schema.enums.every((each) => each.name !== operation.enum);
+    default:
+      return false;
+  }
+}
+function mergeTable(table, asked) {
+  const missing = (have, add) => add.filter((each) => !have.some((had) => had.name === each.name));
+  table.columns.push(...missing(table.columns, asked.columns));
+  table.foreignKeys.push(...missing(table.foreignKeys, asked.foreignKeys));
+  table.indexes.push(...missing(table.indexes, asked.indexes));
+  table.checks.push(...missing(table.checks, asked.checks));
+}
+function laidOver(base, operations2) {
+  const schema = structuredClone(base);
+  const renames = { tables: {}, columns: {} };
+  for (const [index, operation] of structuredClone(operations2).entries()) {
+    const asked = operation.op === "add_table" && namedTable(operation.table);
+    const table = asked ? schema.tables.find((each) => each.name === asked.name) : void 0;
+    const values = operation.op === "add_enum" ? schema.enums.find((each) => each.name === operation.enum.name) : void 0;
+    if (asked && table) {
+      mergeTable(table, asked);
+    } else if (operation.op === "add_enum" && values) {
+      values.values = operation.enum.values;
+    } else if (!alreadyHolds(schema, operation)) {
+      try {
+        apply(schema, renames, operation, index + 1);
+      } catch {
+        return null;
+      }
+    }
+  }
+  return schema;
+}
+function sameSet(a, b) {
+  const said2 = (list) => [...new Set(list)].sort().join();
+  return said2(a) === said2(b);
+}
+function sameTable(a, b) {
+  if (!a || !b) {
+    return a === b;
+  }
+  return sameSet(
+    a.columns.map((each) => each.name),
+    b.columns.map((each) => each.name)
+  ) && sameSet(
+    a.foreignKeys.map(
+      (each) => `${each.columns}>${each.table}.${each.foreignColumns.join()}`
+    ),
+    b.foreignKeys.map(
+      (each) => `${each.columns}>${each.table}.${each.foreignColumns.join()}`
+    )
+  ) && sameSet(
+    a.indexes.map((each) => `${each.unique}(${each.columns})`),
+    b.indexes.map((each) => `${each.unique}(${each.columns})`)
+  ) && sameSet(
+    a.checks.map((each) => each.name),
+    b.checks.map((each) => each.name)
+  );
+}
+function writtenIn(base, operations2) {
+  const schema = laidOver(base, operations2);
+  const { tables, enums } = touchedBy(operations2);
+  const tableOf = (of, name) => of.tables.find((each) => each.name === name);
+  const valuesOf = (of, name) => of.enums.find((each) => each.name === name)?.values.join();
+  return schema !== null && [...tables].every(
+    (name) => sameTable(tableOf(schema, name), tableOf(base, name))
+  ) && [...enums].every((name) => valuesOf(schema, name) === valuesOf(base, name));
+}
+
+// src/core/mark-written.ts
+function markWritten(base, operations2) {
+  const marks = /* @__PURE__ */ new Map();
+  const markOf = (table) => {
+    const mark = marks.get(table) ?? {
+      status: "changed",
+      columns: /* @__PURE__ */ new Map(),
+      foreignKeys: [],
+      indexes: [],
+      checks: /* @__PURE__ */ new Set()
+    };
+    marks.set(table, mark);
+    return mark;
+  };
+  for (const operation of operations2) {
+    switch (operation.op) {
+      case "add_table": {
+        const { name, columns, foreignKeys, indexes, checks } = operation.table;
+        const mark = markOf(name);
+        mark.status = "added";
+        for (const column of columns) {
+          mark.columns.set(column.name, { status: "added" });
+        }
+        mark.foreignKeys.push(...foreignKeys);
+        mark.indexes.push(...indexes);
+        for (const check of checks) {
+          mark.checks.add(check.name);
+        }
+        break;
+      }
+      case "drop_table":
+        marks.delete(operation.table);
+        break;
+      case "rename_table": {
+        const mark = markOf(operation.table);
+        marks.delete(operation.table);
+        marks.set(operation.to, {
+          ...mark,
+          was: mark.status === "added" ? void 0 : mark.was ?? operation.table
+        });
+        break;
+      }
+      case "add_column":
+        markOf(operation.table).columns.set(operation.column.name, {
+          status: "added"
+        });
+        break;
+      case "drop_column":
+        markOf(operation.table).columns.delete(operation.column);
+        break;
+      case "alter_column": {
+        const { columns } = markOf(operation.table);
+        const before = columns.get(operation.column);
+        const name = operation.set.name ?? operation.column;
+        const status = before?.status === "added" ? "added" : "changed";
+        const renamed = name !== operation.column && status === "changed";
+        columns.delete(operation.column);
+        columns.set(name, {
+          status,
+          was: renamed ? before?.was ?? operation.column : before?.was
+        });
+        break;
+      }
+      case "add_foreign_key":
+        markOf(operation.table).foreignKeys.push(operation.foreignKey);
+        break;
+      case "add_index":
+        markOf(operation.table).indexes.push(operation.index);
+        break;
+      case "add_check":
+        markOf(operation.table).checks.add(operation.check.name);
+        break;
+      case "drop_foreign_key":
+      case "drop_index":
+      case "drop_check":
+        markOf(operation.table);
+        break;
+      case "add_enum":
+      case "set_enum_values":
+      case "drop_enum":
+        break;
+    }
+  }
+  const diff = diffDraft(base);
+  return {
+    ...diff,
+    tables: diff.tables.map((table) => {
+      const mark = marks.get(table.name);
+      if (!mark) {
+        return table;
+      }
+      return {
+        ...table,
+        status: mark.status,
+        was: mark.was,
+        columns: table.columns.map((each) => {
+          const column = mark.columns.get(each.column.name);
+          return column ? { ...each, status: column.status, was: column.was } : each;
+        }),
+        foreignKeys: table.foreignKeys.map((each) => ({
+          ...each,
+          status: mark.foreignKeys.some(
+            (asked) => asked.table === each.foreignKey.table && asked.columns.join() === each.foreignKey.columns.join() && asked.foreignColumns.join() === each.foreignKey.foreignColumns.join()
+          ) ? "added" : each.status
+        })),
+        indexes: table.indexes.map((each) => ({
+          ...each,
+          status: mark.indexes.some(
+            (asked) => asked.unique === each.index.unique && asked.columns.join() === each.index.columns.join()
+          ) ? "added" : each.status
+        })),
+        checks: table.checks.map((each) => ({
+          ...each,
+          status: mark.checks.has(each.check.name) ? "added" : each.status
+        }))
+      };
+    })
+  };
+}
+
+// src/core/read-draft.ts
+function readDraft(base, operations2 = []) {
+  try {
+    return { diff: diffDraft(base, operations2), written: false };
+  } catch (error) {
+    if (writtenIn(base, operations2)) {
+      return { diff: markWritten(base, operations2), written: true };
+    }
+    throw error;
+  }
+}
+
+// src/core/describe.ts
+var MARKS = {
+  same: " ",
+  added: "+",
+  removed: "-",
+  changed: "~"
+};
+function said(column, field) {
+  const value = column[field];
+  return value === void 0 ? "none" : String(value);
+}
+function columnLine({ column, status, was, changed, before }) {
+  const words = [
+    column.name,
+    column.type,
+    column.nullable ? "" : "not null",
+    column.primaryKey ? "primary key" : "",
+    column.unique ? "unique" : "",
+    column.default === void 0 ? "" : `default ${column.default}`,
+    column.shape === void 0 ? "" : `shape ${column.shape}`,
+    was ? `(was ${was})` : "",
+    before && changed.length > 0 ? `[${changed.map((field) => `${field}: ${said(before, field)} \u2192 ${said(column, field)}`).join(", ")}]` : ""
+  ];
+  return `  ${MARKS[status]} ${words.filter(Boolean).join(" ")}`;
+}
+function foreignKeyLine({ foreignKey, status }) {
+  const onDelete = foreignKey.onDelete ? ` on delete ${foreignKey.onDelete}` : "";
+  return `  ${MARKS[status]} (${foreignKey.columns.join(", ")}) \u2192 ${foreignKey.table}(${foreignKey.foreignColumns.join(", ")})${onDelete}`;
+}
+function indexLine({ index, status }) {
+  return `  ${MARKS[status]} ${index.unique ? "unique" : "index"} (${index.columns.join(", ")}) ${index.name}`;
+}
+function checkLine({ check, status }) {
+  return `  ${MARKS[status]} check ${check.name}: ${check.expression}`;
+}
+function describeTable(table, diff) {
+  const pointing = (diff?.tables ?? []).flatMap(
+    (other) => other.name === table.name ? [] : other.foreignKeys.filter(({ foreignKey }) => foreignKey.table === table.name).map(
+      ({ foreignKey, status }) => `  ${MARKS[status]} \u2190 ${other.name}(${foreignKey.columns.join(", ")}) \u2192 (${foreignKey.foreignColumns.join(", ")})`
+    )
+  );
+  return [
+    `${MARKS[table.status]} ${table.name}${table.was ? ` (was ${table.was})` : ""}`,
+    ...table.note ? [`    ${table.note}`] : [],
+    ...table.columns.map(columnLine),
+    ...table.foreignKeys.map(foreignKeyLine),
+    ...table.indexes.map(indexLine),
+    ...table.checks.map(checkLine),
+    ...pointing
+  ].join("\n");
+}
+function enumLines(each) {
+  return `${MARKS[each.status]} enum ${each.name}: ${each.values.map(
+    ({ value, status }) => status === "same" ? value : `${MARKS[status]}${value}`
+  ).join(", ")}`;
+}
+function describeTables(diff) {
+  return diff.tables.map(
+    (table) => `${MARKS[table.status]} ${table.name} (${table.columns.length} columns)`
+  ).join("\n");
+}
+function describeDiff(diff) {
+  const tables = diff.tables.filter((table) => table.status !== "same");
+  const enums = diff.enums.filter((each) => each.status !== "same");
+  if (tables.length === 0 && enums.length === 0) {
+    return "No change to the base.";
+  }
+  return [
+    ...tables.map((table) => describeTable(table)),
+    ...enums.map(enumLines)
+  ].join("\n\n");
+}
+function draftLine(draft) {
+  const group = draft.group ? ` [${draft.group}]` : "";
+  return `${draft.id}  ${draft.status.padEnd(9)}${group} ${draft.title}`;
+}
+function describeDraft(draft, diff, written = false) {
+  return [
+    draftLine(draft),
+    ...draft.summary ? [draft.summary] : [],
+    "",
+    written ? "Written in the code: the schema holds what it does." : describeDiff(diff)
+  ].join("\n");
+}
+function describeDecision(draft, drafts, seconds, written = false) {
+  if (draft.status === "adopted") {
+    return written ? `${draft.id} adopted, and written in the code already: nothing left to do.` : `${draft.id} adopted: write it in the schema's code now, then read the schema again; the window says when the code holds it.`;
+  }
+  if (draft.status === "discarded") {
+    const chosen = drafts.find(
+      (each) => each.status === "adopted" && draft.group !== void 0 && each.group === draft.group
+    );
+    return chosen ? `${draft.id} set aside: ${chosen.id} of its group adopted instead (${chosen.title}).` : `${draft.id} set aside: it is no longer an option.`;
+  }
+  return `${draft.id} is still proposed after ${seconds} s. If the person wrote to you meanwhile, answer them first: a change they ask for is revise_draft on it, or a new draft in its group. Otherwise wait again; after about ten minutes, say it waits in the window and stop.`;
+}
+
+// src/core/related-tables.ts
+function relatedTables(diff, table) {
+  const joined = /* @__PURE__ */ new Set([table]);
+  for (const each of diff.tables) {
+    for (const { foreignKey } of each.foreignKeys) {
+      if (each.name === table) {
+        joined.add(foreignKey.table);
+      }
+      if (foreignKey.table === table) {
+        joined.add(each.name);
+      }
+    }
+  }
+  return diff.tables.map((each) => each.name).filter((name) => joined.has(name));
+}
+
+// src/mcp/create-server.ts
+var INSTRUCTIONS = `Erdraft shows a project's data model in a window a person watches while you work, and every proposal you make as a draft beside the schema the code has.
+
+- The project may have several databases: list_databases says which the person works on; every tool works on it.
+- Read before proposing: list_tables, describe_table.
+- Propose a change as a draft (propose_draft): operations on the base, a title and what it is for. It is drawn at once in the window, its tables and columns marked added, changed or removed.
+- When asked for ideas or there is more than one good answer, propose two or three alternatives, each its own draft, sharing one group, so the person compares them side by side.
+- Build a large draft step by step with revise_draft (mode append); the window follows each step.
+- Where a field of the project's app keeps its value (a column, the browser's storage, or nowhere), as Erdraft's inspector traced it, is list_fields: a change asked for "this field" starts from its column.
+- When the person asks to see, show or open something (a table, its relationships, a draft, the whole schema), show it in the window with show_in_window rather than describing it at length.
+- A draft holds the whole design: its tables and columns, their foreign keys, and the rules Postgres holds, its indexes (unique or not) and checks, each an operation, never a note; a json or jsonb column with its shape, the person reading it in the window, and written as a zod schema the module exports as <table><Column>Shape (websites.theme: websitesThemeShape), its type inferred from it, so the window reads the shape back from the code.
+- A draft proposes; the person adopts one in the window. After proposing, wait for the person's choice with wait_for_decision, rather than asking them to say it: in short waits, one after another, answering what the person writes to you between them. Never write a draft into the code until it is adopted; then write it in the schema's code, and read_schema again.`;
+function text(value) {
+  return { content: [{ type: "text", text: value }] };
+}
+async function answer(work) {
+  try {
+    return text(await work());
+  } catch (error) {
+    return { ...text(String(error)), isError: true };
+  }
+}
+var draftId = z5.string().describe("A draft\u2019s id, as list_drafts gives it (d1, d2...)");
+var operations = z5.array(operationSchema).describe(
+  'Operations on the schema, applied in order: add_table (its indexes and checks with it), drop_table, rename_table, add_column, drop_column, alter_column (set: the fields that change, a new name included), add_foreign_key, drop_foreign_key, add_index (unique or not, on columns of the table), drop_index, add_check (its name and its SQL), drop_check, add_enum, set_enum_values, drop_enum. Types as Postgres names them (integer, text, varchar(120), timestamp with time zone, jsonb), an enum column\u2019s type its enum\u2019s name; a json or jsonb column\u2019s shape its TypeScript type, as the code\u2019s $type<...>() writes it ({ accent?: string; tone: "light" | "dark" }).'
+);
+function createServer({ config }) {
+  const server = new McpServer(
+    { name: "erdraft", version: version_default },
+    { instructions: INSTRUCTIONS }
+  );
+  const windowUrl = `http://localhost:${config.port}`;
+  async function opened() {
+    const database = await currentDatabase(config);
+    return { database, store: storeOf(config, database) };
+  }
+  async function baseSchema2({ database, store: store2 }) {
+    const base = await store2.readBase();
+    return base ? base.schema : (await readSchema(config, database, store2)).schema;
+  }
+  async function schemaOf(open, draft) {
+    const schema = await baseSchema2(open);
+    return readDraft(
+      schema,
+      draft ? (await open.store.draft(draft)).operations : []
+    ).diff;
+  }
+  server.registerTool(
+    "list_databases",
+    {
+      title: "List the databases",
+      description: "The project\u2019s databases, * the one the person works on now: every other tool works on it. The person switches in the window."
+    },
+    () => answer(async () => {
+      const { database } = await opened();
+      return config.databases.map(
+        (each) => `${each.id === database.id ? "*" : " "} ${each.id}  ${each.name}`
+      ).join("\n");
+    })
+  );
+  server.registerTool(
+    "read_schema",
+    {
+      title: "Read the schema",
+      description: "Read the schema again from the code (the Drizzle module), after the code changed. Every draft is applied to it."
+    },
+    () => answer(async () => {
+      const { database, store: store2 } = await opened();
+      const base = await readSchema(config, database, store2);
+      return `Read ${base.schema.tables.length} tables and ${base.schema.enums.length} enums from ${base.source}.`;
+    })
+  );
+  server.registerTool(
+    "list_tables",
+    {
+      title: "List the tables",
+      description: "Every table with its number of columns; with a draft, the draft\u2019s, marked + added, - removed, ~ changed.",
+      inputSchema: { draft: draftId.optional() }
+    },
+    ({ draft }) => answer(async () => describeTables(await schemaOf(await opened(), draft)))
+  );
+  server.registerTool(
+    "describe_table",
+    {
+      title: "Describe a table",
+      description: "A table\u2019s columns (type, not null, primary key, unique, default) and foreign keys; with a draft, as the draft has it.",
+      inputSchema: { name: z5.string(), draft: draftId.optional() }
+    },
+    ({ name, draft }) => answer(async () => {
+      const diff = await schemaOf(await opened(), draft);
+      const table = diff.tables.find((each) => each.name === name);
+      if (!table) {
+        throw new Error(`There is no table "${name}"`);
+      }
+      return describeTable(table, diff);
+    })
+  );
+  server.registerTool(
+    "list_drafts",
+    {
+      title: "List the drafts",
+      description: "Every draft: id, status (proposed, adopted, discarded), group and title. An adopted draft is the person\u2019s choice, to be written in the code."
+    },
+    () => answer(async () => {
+      const drafts = await (await opened()).store.readDrafts();
+      return drafts.length > 0 ? drafts.map(draftLine).join("\n") : "No drafts yet.";
+    })
+  );
+  server.registerTool(
+    "show_draft",
+    {
+      title: "Show a draft",
+      description: "A draft in full: what it is for and every table and enum it changes.",
+      inputSchema: { id: draftId }
+    },
+    ({ id }) => answer(async () => {
+      const open = await opened();
+      const draft = await open.store.draft(id);
+      const { diff, written } = readDraft(
+        await baseSchema2(open),
+        draft.operations
+      );
+      return describeDraft(draft, diff, written);
+    })
+  );
+  server.registerTool(
+    "propose_draft",
+    {
+      title: "Propose a draft",
+      description: "A new draft: operations on the schema, drawn at once in the window for the person to see. Alternatives to one question share a group.",
+      inputSchema: {
+        title: z5.string().min(1).describe("What the draft does, in a few words"),
+        summary: z5.string().optional().describe("Why, and what it trades, in a sentence or two"),
+        group: z5.string().optional().describe(
+          "A short name shared by the alternatives to one question (project-tags)"
+        ),
+        operations
+      }
+    },
+    (input) => answer(async () => {
+      const open = await opened();
+      const schema = await baseSchema2(open);
+      const draft = await open.store.propose(input);
+      return `Proposed ${draft.id}: ${draft.title}. Shown at ${windowUrl}/?draft=${draft.id}
+
+${describeDiff(diffDraft(schema, draft.operations))}`;
+    })
+  );
+  server.registerTool(
+    "revise_draft",
+    {
+      title: "Revise a draft",
+      description: "Change a draft: operations added after its own (mode append, the default) or put in their place (mode replace), its title, summary or group. It is proposed again.",
+      inputSchema: {
+        id: draftId,
+        operations: operations.optional(),
+        mode: z5.enum(["append", "replace"]).optional(),
+        title: z5.string().min(1).optional(),
+        summary: z5.string().optional(),
+        group: z5.string().optional()
+      }
+    },
+    ({ id, ...revision }) => answer(async () => {
+      const open = await opened();
+      const schema = await baseSchema2(open);
+      const draft = await open.store.revise(id, revision);
+      return `Revised ${draft.id}: ${draft.title}.
+
+${describeDiff(diffDraft(schema, draft.operations))}`;
+    })
+  );
+  server.registerTool(
+    "wait_for_decision",
+    {
+      title: "Wait for the person\u2019s decision",
+      description: "Wait until the person adopts a draft or sets it aside in the window (adopting another of its group sets it aside), or the time is up; then say what to do next. Call it after proposing, instead of asking the person to say they adopted. Keep each wait short and call it again: what the person writes to you is read only between waits.",
+      inputSchema: {
+        id: draftId,
+        seconds: z5.number().int().min(1).max(120).optional().describe(
+          `How long to wait at most, ${DECISION_SECONDS} when left out`
+        )
+      }
+    },
+    ({ id, seconds = DECISION_SECONDS }, { signal }) => answer(async () => {
+      const open = await opened();
+      const draft = await open.store.decision(
+        id,
+        seconds * 1e3,
+        void 0,
+        signal
+      );
+      return describeDecision(
+        draft,
+        await open.store.readDrafts(),
+        seconds,
+        writtenIn(await baseSchema2(open), draft.operations)
+      );
+    })
+  );
+  server.registerTool(
+    "show_in_window",
+    {
+      title: "Show in the window",
+      description: "Change what the window shows the person: a table in focus, only it and the tables it joins (related), a draft (draft: its id; null: the schema as the code has it). With no table and related false, the whole diagram.",
+      inputSchema: {
+        table: z5.string().optional().describe(
+          "The table to focus (one a draft adds: give that draft too)"
+        ),
+        related: z5.boolean().optional().describe(
+          "Draw only the table and the tables it joins by a foreign key, either way"
+        ),
+        draft: draftId.nullable().optional().describe(
+          "Leave it out (most often): the window keeps the draft it shows, or the schema. A draft\u2019s id only when the person asks to open that draft, or the table is one a draft adds; null only when they ask to leave the draft for the schema as the code has it"
+        )
+      }
+    },
+    ({ table, related, draft }) => answer(async () => {
+      const open = await opened();
+      const diff = await schemaOf(open, draft ?? void 0);
+      if (table !== void 0 && !diff.tables.some((each) => each.name === table)) {
+        throw new Error(`There is no table "${table}"`);
+      }
+      await open.store.show({
+        table: table ?? null,
+        related: related === true && table !== void 0,
+        draft
+      });
+      const shown = draft === null ? "the schema as the code has it" : draft ? `draft ${draft}` : "what the window shows, its draft or the schema kept";
+      if (table === void 0) {
+        return `Shown in the window: ${shown}, whole.`;
+      }
+      const joined = relatedTables(diff, table).length - 1;
+      return related ? `Shown in the window: ${table} and the ${joined} table${joined === 1 ? "" : "s"} it joins, in ${shown}.` : `Shown in the window: ${table} in focus, in ${shown}.`;
+    })
+  );
+  server.registerTool(
+    "list_fields",
+    {
+      title: "List the fields traced",
+      description: "The project's app's fields Erdraft's inspector traced, page by page, each with where it keeps its value: a table's column, a key of the browser's storage, or nowhere (kept on the page only, or not saved yet).",
+      inputSchema: {
+        page: z5.string().optional().describe("A page's path (/project): its fields alone")
+      }
+    },
+    ({ page }) => answer(
+      async () => describeFields(await (await opened()).store.readFields(page))
+    )
+  );
+  server.registerTool(
+    "discard_draft",
+    {
+      title: "Discard a draft",
+      description: "Set a draft aside, when it is no longer an option.",
+      inputSchema: { id: draftId }
+    },
+    ({ id }) => answer(async () => {
+      const draft = await (await opened()).store.setStatus(id, "discarded");
+      return `Discarded ${draft.id}: ${draft.title}.`;
+    })
+  );
+  return server;
+}
+
+// src/server/create-api.ts
+import { z as z9 } from "zod";
+import { mkdirSync, watch } from "fs";
+import { text as text4 } from "stream/consumers";
+
+// src/server/create-assistant.ts
+import { z as z7 } from "zod";
+import { spawn as spawnProcess } from "child_process";
+import { text as text2 } from "stream/consumers";
+import { createInterface } from "readline";
+
+// src/server/read-stream-line.ts
+import { z as z6 } from "zod";
+var TOOL_PREFIX = "mcp__erdraft__";
+var blockStart = z6.object({
+  type: z6.literal("stream_event"),
+  event: z6.object({
+    type: z6.literal("content_block_start"),
+    content_block: z6.discriminatedUnion("type", [
+      z6.object({ type: z6.literal("text") }),
+      z6.object({ type: z6.literal("tool_use"), name: z6.string() })
+    ])
+  })
+});
+var textDelta = z6.object({
+  type: z6.literal("stream_event"),
+  event: z6.object({
+    type: z6.literal("content_block_delta"),
+    delta: z6.object({ type: z6.literal("text_delta"), text: z6.string() })
+  })
+});
+var result = z6.object({
+  type: z6.literal("result"),
+  session_id: z6.string(),
+  is_error: z6.boolean()
+});
+function parsed(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+}
+function readStreamLine(line) {
+  const value = parsed(line);
+  const start = blockStart.safeParse(value);
+  if (start.success) {
+    const block = start.data.event.content_block;
+    return block.type === "text" ? { type: "text" } : { type: "tool", name: block.name.replace(TOOL_PREFIX, "") };
+  }
+  const delta = textDelta.safeParse(value);
+  if (delta.success) {
+    return { type: "delta", text: delta.data.event.delta.text };
+  }
+  const end = result.safeParse(value);
+  if (end.success) {
+    return {
+      type: "done",
+      session: end.data.session_id,
+      error: end.data.is_error
+    };
+  }
+  return null;
+}
+
+// src/server/create-assistant.ts
+var askSchema = z7.object({
+  message: z7.string().trim().min(1),
+  session: z7.uuid().optional(),
+  context: z7.object({
+    draft: z7.object({ id: z7.string(), title: z7.string() }).optional(),
+    table: z7.string().optional(),
+    column: z7.string().optional()
+  }).optional()
+});
+var SELF = {
+  command: process.execPath,
+  args: [...process.execArgv, ...process.argv.slice(1, 2), "mcp"]
+};
+function promptOf(config, context) {
+  const seen = context ? [
+    context.draft ? `The window shows draft ${context.draft.id} ("${context.draft.title}"); "this", "it" or "here" is that draft.` : "The window shows the schema as the code has it: no draft is open, whatever earlier messages said.",
+    context.table ? `The person has the table ${context.table} in focus.` : "",
+    context.column ? `Its column ${context.column} is lit: where a field of the app keeps its value, traced by Erdraft's inspector; "this field" or "this column" is it.` : ""
+  ] : [
+    "The person chose not to say what the window shows: ask which draft when it matters."
+  ];
+  return [
+    `You are Erdraft's assistant, in the panel beside its window, on ${config.name}'s data model.`,
+    INSTRUCTIONS,
+    "Answer in the language the person writes in, briefly, as in a chat, in plain sentences (no Markdown headings nor tables). Read and propose with the erdraft tools alone: you cannot change the code nor the database, and say so when asked to. A draft you propose is drawn in the window at once; say what it does in a sentence, not table by table.",
+    ...seen.filter(Boolean)
+  ].join("\n\n");
+}
+function argumentsOf(config, ask) {
+  return [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--include-partial-messages",
+    "--mcp-config",
+    JSON.stringify({
+      mcpServers: { erdraft: SELF }
+    }),
+    "--strict-mcp-config",
+    "--tools",
+    "",
+    "--allowedTools",
+    "mcp__erdraft",
+    "--model",
+    config.model,
+    "--append-system-prompt",
+    promptOf(config, ask.context),
+    ...ask.session ? ["--resume", ask.session] : []
+  ];
+}
+function send(response, event) {
+  response.write(`data: ${JSON.stringify(event)}
+
+`);
+}
+function createAssistant(config, spawn = spawnProcess) {
+  return async function ask(request, response) {
+    const asked = askSchema.safeParse(JSON.parse(await text2(request) || "{}"));
+    if (!asked.success) {
+      response.writeHead(400, { "content-type": "application/json" });
+      response.end(JSON.stringify({ error: z7.prettifyError(asked.error) }));
+      return;
+    }
+    response.writeHead(200, {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache"
+    });
+    response.flushHeaders();
+    const agent = spawn(config.claude, argumentsOf(config, asked.data), {
+      cwd: config.root,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let ended = false;
+    agent.stdin.end(asked.data.message);
+    response.on("close", () => agent.kill());
+    agent.on("error", (error) => {
+      ended = true;
+      send(response, {
+        type: "error",
+        message: `Claude Code could not be started (${config.claude}): ${error.message}`
+      });
+    });
+    createInterface({ input: agent.stdout }).on("line", (line) => {
+      const event = readStreamLine(line);
+      if (event) {
+        ended ||= event.type === "done";
+        send(response, event);
+      }
+    });
+    const errors = [];
+    agent.stderr.on("data", (chunk) => errors.push(chunk.toString()));
+    agent.on("close", () => {
+      if (!ended) {
+        send(response, {
+          type: "error",
+          message: errors.join("").trim().split("\n").at(-1) || "The assistant stopped without an answer."
+        });
+      }
+      response.end();
+    });
+  };
+}
+
+// src/server/create-inspect-api.ts
+import { z as z8 } from "zod";
+import { text as text3 } from "stream/consumers";
+
+// src/inspect/holds-value.ts
+var SHORTEST = 2;
+var WITHIN = 4;
+var DIGITS = 4;
+function digitsOf(value) {
+  return value.replace(/\D/g, "");
+}
+function holdsValue(kept, typed) {
+  const value = typed.trim().toLowerCase();
+  if (value.length < SHORTEST || kept === null || kept === void 0) {
+    return false;
+  }
+  const text5 = (typeof kept === "string" ? kept : JSON.stringify(kept)).toLowerCase();
+  const digits = digitsOf(value);
+  return text5.trim() === value || digits.length >= DIGITS && digits === digitsOf(text5) || value.length >= WITHIN && text5.includes(value);
+}
+
+// src/server/create-inspect-api.ts
+var KEPT_WRITES = 500;
+var KEPT_FOR = 15 * 6e4;
+var writesSchema = z8.object({
+  writes: z8.array(
+    z8.object({ table: z8.string(), values: z8.record(z8.string(), z8.unknown()) })
+  )
+});
+var tracedSchema = fieldSchema.omit({ tracedAt: true });
+function json(response, status, value, headers) {
+  response.writeHead(status, { ...headers, "content-type": "application/json" });
+  response.end(JSON.stringify(value));
+}
+async function body(request) {
+  return JSON.parse(await text3(request) || "{}");
+}
+function createInspectApi(now = Date.now) {
+  let written = [];
+  return async function handle(request, response, drafts) {
+    const url = new URL(String(request.url), "http://localhost");
+    if (!url.pathname.startsWith("/api/inspect/")) {
+      return false;
+    }
+    const { origin } = request.headers;
+    const headers = origin ? {
+      "access-control-allow-origin": origin,
+      "access-control-allow-methods": "GET, POST",
+      "access-control-allow-headers": "content-type",
+      vary: "origin"
+    } : {};
+    if (request.method === "OPTIONS") {
+      response.writeHead(204, headers);
+      response.end();
+      return true;
+    }
+    if (request.method === "POST" && url.pathname === "/api/inspect/writes") {
+      const sent = writesSchema.safeParse(await body(request));
+      if (!sent.success) {
+        json(response, 400, { error: z8.prettifyError(sent.error) }, headers);
+        return true;
+      }
+      const at = now();
+      written = [
+        ...written.filter((write) => at - write.at < KEPT_FOR),
+        ...sent.data.writes.map((write) => ({ ...write, at }))
+      ].slice(-KEPT_WRITES);
+      json(response, 200, { ok: true }, headers);
+      return true;
+    }
+    if (request.method === "GET" && url.pathname === "/api/inspect/find") {
+      const value = url.searchParams.get("value") ?? "";
+      const since = Number(url.searchParams.get("since") ?? 0);
+      const found = /* @__PURE__ */ new Map();
+      for (const write of [...written].reverse()) {
+        if (write.at < since) {
+          continue;
+        }
+        for (const [column, kept] of Object.entries(write.values)) {
+          const key = `${write.table}.${column}`;
+          if (!found.has(key) && holdsValue(kept, value)) {
+            found.set(key, { table: write.table, column, at: write.at });
+          }
+        }
+      }
+      json(response, 200, { columns: [...found.values()] }, headers);
+      return true;
+    }
+    if (request.method === "GET" && url.pathname === "/api/inspect/fields") {
+      const page = url.searchParams.get("page") ?? void 0;
+      json(response, 200, { fields: await drafts.readFields(page) }, headers);
+      return true;
+    }
+    if (request.method === "POST" && url.pathname === "/api/inspect/fields") {
+      const field = tracedSchema.safeParse(await body(request));
+      if (!field.success) {
+        json(response, 400, { error: z8.prettifyError(field.error) }, headers);
+        return true;
+      }
+      const kept = await drafts.saveField(field.data);
+      const { destination } = field.data;
+      if (destination.kind === "column") {
+        await drafts.show({
+          table: destination.table,
+          column: destination.column
+        });
+      }
+      json(response, 200, { field: kept }, headers);
+      return true;
+    }
+    return false;
+  };
+}
+
+// src/server/refusal-of.ts
+var LARGEST_BODY = 1e6;
+function loopback(url) {
+  if (!URL.canParse(url)) {
+    return false;
+  }
+  const { hostname } = new URL(url);
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname.endsWith(".localhost");
+}
+function refusalOf(request, asker) {
+  const host = `http://${request.headers.host ?? ""}`;
+  const { origin } = request.headers;
+  if (!loopback(host)) {
+    return { status: 403, error: "Asked of a host that is not this machine" };
+  }
+  if (origin !== void 0 && (asker === "window" ? origin !== new URL(host).origin : !loopback(origin))) {
+    return { status: 403, error: "Asked from a page of another site" };
+  }
+  if (Number(request.headers["content-length"] ?? 0) > LARGEST_BODY) {
+    return { status: 413, error: "The body is too large" };
+  }
+  return void 0;
+}
+
+// src/server/create-api.ts
+var SETTLE = 40;
+var DRAFT_ACTION = /^\/api\/drafts\/([^/]+)\/(adopt|discard)$/;
+var DRAFT_DELETE = /^\/api\/drafts\/([^/]+)$/;
+var layoutSchema = z9.object({ key: z9.string().min(1), places: placesSchema });
+function json2(response, status, value) {
+  response.writeHead(status, { "content-type": "application/json" });
+  response.end(JSON.stringify(value));
+}
+function createApi(config, { spawn } = {}) {
+  const ask = createAssistant(config, spawn);
+  const inspect = createInspectApi();
+  const clients = /* @__PURE__ */ new Set();
+  let timer;
+  mkdirSync(config.store, { recursive: true });
+  const watcher = watch(config.store, { recursive: true }, () => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      for (const client of clients) {
+        client.write("event: change\ndata: {}\n\n");
+      }
+    }, SETTLE);
+  });
+  async function handle(request, response) {
+    const { pathname } = new URL(String(request.url), "http://localhost");
+    if (!pathname.startsWith("/api/")) {
+      return false;
+    }
+    const refused = refusalOf(
+      request,
+      pathname.startsWith("/api/inspect/") ? "app" : "window"
+    );
+    if (refused) {
+      json2(response, refused.status, { error: refused.error });
+      return true;
+    }
+    const database = await currentDatabase(config);
+    const drafts = storeOf(config, database);
+    if (await inspect(request, response, drafts)) {
+      return true;
+    }
+    if (request.method === "GET" && pathname === "/api/state") {
+      json2(response, 200, {
+        name: config.name,
+        port: config.port,
+        databases: config.databases.map(({ id, name }) => ({ id, name })),
+        database: { id: database.id, name: database.name },
+        ...await drafts.read()
+      });
+      return true;
+    }
+    if (request.method === "GET" && pathname === "/api/events") {
+      response.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache",
+        connection: "keep-alive"
+      });
+      response.write(": connected\n\n");
+      clients.add(response);
+      request.on("close", () => clients.delete(response));
+      return true;
+    }
+    if (request.method === "POST" && pathname === "/api/assistant") {
+      await ask(request, response);
+      return true;
+    }
+    if (request.method === "POST" && pathname === "/api/database") {
+      const chosen = z9.object({ id: z9.string() }).safeParse(JSON.parse(await text4(request) || "{}"));
+      try {
+        const id = chosen.success ? chosen.data.id : "";
+        json2(response, 200, await chooseDatabase(config, id));
+      } catch (error) {
+        json2(response, 404, { error: String(error) });
+      }
+      return true;
+    }
+    if (request.method === "PUT" && pathname === "/api/layout") {
+      const layout = layoutSchema.safeParse(
+        JSON.parse(await text4(request) || "{}")
+      );
+      if (!layout.success) {
+        json2(response, 400, { error: z9.prettifyError(layout.error) });
+        return true;
+      }
+      await drafts.saveLayout(layout.data.key, layout.data.places);
+      json2(response, 200, { ok: true });
+      return true;
+    }
+    const deleted = DRAFT_DELETE.exec(pathname);
+    if (request.method === "DELETE" && deleted) {
+      try {
+        json2(response, 200, await drafts.deleteDraft(String(deleted[1])));
+      } catch (error) {
+        json2(response, 404, { error: String(error) });
+      }
+      return true;
+    }
+    const action = DRAFT_ACTION.exec(pathname);
+    if (request.method === "POST" && action) {
+      try {
+        json2(
+          response,
+          200,
+          await drafts.setStatus(
+            String(action[1]),
+            action[2] === "adopt" ? "adopted" : "discarded"
+          )
+        );
+      } catch (error) {
+        json2(response, 404, { error: String(error) });
+      }
+      return true;
+    }
+    return false;
+  }
+  return {
+    middleware(request, response, next) {
+      handle(request, response).then(
+        (handled) => handled ? void 0 : next(),
+        next
+      );
+    },
+    close() {
+      clearTimeout(timer);
+      watcher.close();
+      for (const client of clients) {
+        client.end();
+      }
+    }
+  };
+}
+
+export {
+  DECISION_SECONDS,
+  storeOf,
+  currentDatabase,
+  databaseOf,
+  chooseDatabase,
+  version_default,
+  readSchema,
+  writtenIn,
+  readDraft,
+  describeTable,
+  describeTables,
+  draftLine,
+  describeDraft,
+  describeDecision,
+  createServer,
+  createApi
+};