@henols/c64-re-tools 2.0.0-rc.8 → 2.0.0

package/src/knowledge/expression.ts

@@ -0,0 +1,209 @@
+// Operand expressions: the part of ACME's expression syntax that names
+// an operand by symbols and numbers. Knowledge checks an expression against
+// the image with it, and c64-source writes it with the names of its layout.
+//
+// Priorities are ACME's, from high to low: unary - and !, then * / %, + -,
+// << >> >>>, unary < and >, &, XOR, |. A unary < or > takes everything of a
+// higher priority after it, so <a+1 is the low byte of a+1.
+
+/** An expression that does not parse, or that names a symbol with no value. */
+export class ExpressionError extends Error {
+  override name = "ExpressionError";
+}
+
+/** The selectors of an operand expression: a byte of a symbol, its value, or free expression text. */
+export const OPERAND_SELECTS = ["lo", "hi", "value", "expr"] as const;
+export type OperandSelect = (typeof OPERAND_SELECTS)[number];
+
+/** An operand expression as knowledge stores it: a symbol with an offset, or text for expr. */
+export interface OperandExpression {
+  select: OperandSelect;
+  symbol?: string;
+  offset?: number;
+  expression?: string;
+}
+
+type Node =
+  | { kind: "number"; value: number }
+  | { kind: "name"; name: string }
+  | { kind: "unary"; operator: string; operand: Node }
+  | { kind: "binary"; operator: string; left: Node; right: Node };
+
+/** Binary operators by priority (higher binds tighter); unary < and > sit at LOW_HIGH. */
+const BINARY: Record<string, number> = { "*": 10, "/": 10, "%": 10, "+": 9, "-": 9, "<<": 8, ">>": 8, ">>>": 8, "&": 4, XOR: 3, "|": 2 };
+const LOW_HIGH = 7;
+const NAME = /^[A-Za-z_.][A-Za-z0-9_]*/;
+const MAX_TEXT = 200;
+
+interface Token {
+  text: string;
+  at: number;
+}
+
+/** The expression as tokens with their offsets; context decides % (binary literal or remainder). */
+function tokenize(text: string): Token[] {
+  const tokens: Token[] = [];
+  let at = 0;
+  let operandNext = true;
+  while (at < text.length) {
+    const rest = text.slice(at);
+    const space = /^\s+/.exec(rest);
+    if (space) {
+      at += space[0].length;
+      continue;
+    }
+    const number: RegExpExecArray | null = operandNext ? /^(\$[0-9A-Fa-f]+|%[01]+|[0-9]+)/.exec(rest) : null;
+    const match: RegExpExecArray | null = number ?? /^(>>>|<<|>>|XOR\b)/.exec(rest) ?? NAME.exec(rest) ?? /^[-+*/%&|!<>()]/.exec(rest);
+    if (!match) throw new ExpressionError(`"${text}" has an unknown character at position ${at + 1}: "${rest[0]}".`);
+    const token: string = match[0];
+    tokens.push({ text: token, at });
+    at += token.length;
+    // After an operand or a ), an operator comes next; after anything else, an operand.
+    operandNext = !(number !== null || (NAME.test(token) && token !== "XOR") || token === ")");
+  }
+  return tokens;
+}
+
+function parse(text: string): Node {
+  if (text.trim().length === 0) throw new ExpressionError("An expression is empty.");
+  if (text.length > MAX_TEXT) throw new ExpressionError(`An expression has at most ${MAX_TEXT} characters.`);
+  const tokens = tokenize(text);
+  let index = 0;
+  const peek = () => tokens[index]?.text;
+  const fail = (what: string): never => {
+    throw new ExpressionError(`"${text}" ${what}.`);
+  };
+
+  const operand = (): Node => {
+    const token = tokens[index++]?.text ?? fail("ends where an operand is missing");
+    if (token === "(") {
+      const inner = binary(0);
+      if (tokens[index++]?.text !== ")") fail("has a ( with no )");
+      return inner;
+    }
+    if (token === "-" || token === "!") return { kind: "unary", operator: token, operand: operand() };
+    if (token === "<" || token === ">") return { kind: "unary", operator: token, operand: binary(LOW_HIGH + 1) };
+    if (token.startsWith("$")) return { kind: "number", value: Number.parseInt(token.slice(1), 16) };
+    if (token.startsWith("%")) return { kind: "number", value: Number.parseInt(token.slice(1), 2) };
+    if (/^[0-9]/.test(token)) return { kind: "number", value: Number.parseInt(token, 10) };
+    if (NAME.test(token) && token !== "XOR") return { kind: "name", name: token };
+    return fail(`has "${token}" where an operand must be`);
+  };
+
+  const binary = (minimum: number): Node => {
+    let left = operand();
+    for (;;) {
+      const operator = peek();
+      const priority = operator === undefined ? undefined : BINARY[operator];
+      if (priority === undefined || priority < minimum) return left;
+      index++;
+      left = { kind: "binary", operator: operator!, left, right: binary(priority + 1) };
+    }
+  };
+
+  const tree = binary(0);
+  if (index < tokens.length) fail(`has "${tokens[index]!.text}" after the end of the expression`);
+  return tree;
+}
+
+function names(node: Node, into: string[]): string[] {
+  if (node.kind === "name" && !into.includes(node.name)) into.push(node.name);
+  if (node.kind === "unary") names(node.operand, into);
+  if (node.kind === "binary") {
+    names(node.left, into);
+    names(node.right, into);
+  }
+  return into;
+}
+
+function value(node: Node, resolve: (name: string) => number | undefined): number {
+  switch (node.kind) {
+    case "number":
+      return node.value;
+    case "name": {
+      const found = resolve(node.name);
+      if (found === undefined) throw new ExpressionError(`"${node.name}" is no symbol of the knowledge and no platform name.`);
+      return found;
+    }
+    case "unary": {
+      const inner = value(node.operand, resolve);
+      if (node.operator === "-") return -inner;
+      if (node.operator === "!") return ~inner;
+      return node.operator === "<" ? inner & 0xff : (inner >> 8) & 0xff;
+    }
+    case "binary": {
+      const left = value(node.left, resolve);
+      const right = value(node.right, resolve);
+      switch (node.operator) {
+        case "*":
+          return left * right;
+        case "/":
+        case "%":
+          if (right === 0) throw new ExpressionError("An expression divides by zero.");
+          return node.operator === "/" ? Math.trunc(left / right) : left % right;
+        case "+":
+          return left + right;
+        case "-":
+          return left - right;
+        case "<<":
+          return left << right;
+        case ">>":
+          return left >> right;
+        case ">>>":
+          return left >>> right;
+        case "&":
+          return left & right;
+        case "XOR":
+          return left ^ right;
+        default:
+          return left | right;
+      }
+    }
+  }
+}
+
+/** Throws ExpressionError when the text is no expression of this syntax. */
+export function checkExpression(text: string): void {
+  parse(text);
+}
+
+/** The value of the expression; `resolve` gives the value of a name, or undefined. */
+export function evaluate(text: string, resolve: (name: string) => number | undefined): number {
+  return value(parse(text), resolve);
+}
+
+/** The names the expression uses, each once, in their order. */
+export function identifiers(text: string): string[] {
+  return names(parse(text), []);
+}
+
+/**
+ * The text with each name replaced by `replace(name)` (a name it returns
+ * unchanged stays). Spaces and other tokens stay as written.
+ */
+export function replaceIdentifiers(text: string, replace: (name: string) => string): string {
+  parse(text);
+  let out = "";
+  let from = 0;
+  for (const token of tokenize(text)) {
+    if (!NAME.test(token.text) || token.text === "XOR") continue;
+    out += text.slice(from, token.at) + replace(token.text);
+    from = token.at + token.text.length;
+  }
+  return out + text.slice(from);
+}
+
+function offsetText(offset: number): string {
+  const size = Math.abs(offset);
+  return `${offset < 0 ? "-" : "+"}${size < 10 ? String(size) : `$${size.toString(16)}`}`;
+}
+
+/** ACME text of an operand expression, for example <irq_handler, >(sprite_bank+$1000) or bar_colours-1. */
+export function operandText(operand: OperandExpression): string {
+  if (operand.select === "expr") return operand.expression!;
+  const offset = operand.offset ?? 0;
+  const sum = offset === 0 ? operand.symbol! : `${operand.symbol!}${offsetText(offset)}`;
+  if (operand.select === "value") return sum;
+  const selector = operand.select === "lo" ? "<" : ">";
+  return offset === 0 ? `${selector}${sum}` : `${selector}(${sum})`;
+}

package/src/knowledge/graph.ts

@@ -0,0 +1,104 @@
+// The routine graph of the knowledge: which routine calls, jumps
+// to or dispatches through a table to which other routine, and the same
+// graph as a mermaid flowchart. The callers give the rows, so the graph needs
+// no database and the documentation and the knowledge script draw one graph.
+
+import { formatC64Address } from "../c64.ts";
+import type { ReferenceKind, SymbolKind } from "./schema.ts";
+
+/** How one routine reaches another: a call, a jump, or an entry of a table of addresses. */
+export type EdgeKind = "call" | "jump" | "table";
+
+export interface GraphReference {
+  from: number;
+  to: number;
+  kind: ReferenceKind | "table";
+}
+
+export interface RoutineHead {
+  address: number;
+  name: string;
+}
+
+export interface GraphEdge {
+  from: number;
+  to: number;
+  /** The strongest kind of the references that make the edge: a call, then a table entry, then a jump. */
+  kind: EdgeKind;
+  /** The references that make the edge. */
+  count: number;
+}
+
+const STRENGTH: Record<EdgeKind, number> = { call: 3, table: 2, jump: 1 };
+
+/**
+ * The routine heads: every routine of the knowledge, and every call or table
+ * target, which another routine enters at its start. A head without a name of
+ * the knowledge gets the name that `nameOf` gives.
+ */
+export function routineHeads(symbols: ReadonlyArray<{ address: number; name: string; kind: SymbolKind }>, references: readonly GraphReference[], nameOf: (address: number) => string): RoutineHead[] {
+  const names = new Map(symbols.map((symbol) => [symbol.address, symbol.name]));
+  const heads = new Set(symbols.filter((symbol) => symbol.kind === "routine").map((symbol) => symbol.address));
+  for (const reference of references) if (reference.kind === "call" || reference.kind === "table") heads.add(reference.to);
+  return [...heads].sort((a, b) => a - b).map((address) => ({ address, name: names.get(address) ?? nameOf(address) }));
+}
+
+/**
+ * The head that holds an address: the nearest head at or below it, when no
+ * boundary (a module start) lies between the two.
+ */
+export function ownerOf(heads: readonly RoutineHead[], boundaries: readonly number[], address: number): RoutineHead | undefined {
+  let low = 0;
+  let high = heads.length - 1;
+  let found: RoutineHead | undefined;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    if (heads[middle]!.address <= address) {
+      found = heads[middle];
+      low = middle + 1;
+    } else high = middle - 1;
+  }
+  if (found === undefined) return undefined;
+  return boundaries.some((boundary) => boundary > found.address && boundary <= address) ? undefined : found;
+}
+
+/** The edges between routines: each call, jump or table reference from one head's code to another head; a jump inside a routine is no edge. */
+export function routineEdges(heads: readonly RoutineHead[], boundaries: readonly number[], references: readonly GraphReference[]): GraphEdge[] {
+  const edges = new Map<string, GraphEdge>();
+  for (const reference of references) {
+    if (reference.kind !== "call" && reference.kind !== "jump" && reference.kind !== "table") continue;
+    const from = ownerOf(heads, boundaries, reference.from);
+    const to = ownerOf(heads, boundaries, reference.to);
+    if (from === undefined || to === undefined || from.address === to.address) continue;
+    // A jump into the middle of another routine is an edge to that routine.
+    const key = `${from.address}:${to.address}`;
+    const edge = edges.get(key);
+    if (edge === undefined) edges.set(key, { from: from.address, to: to.address, kind: reference.kind, count: 1 });
+    else {
+      edge.count++;
+      if (STRENGTH[reference.kind] > STRENGTH[edge.kind]) edge.kind = reference.kind;
+    }
+  }
+  return [...edges.values()].sort((a, b) => a.from - b.from || a.to - b.to);
+}
+
+const ARROWS: Record<EdgeKind, string> = { call: "-->", table: "==>", jump: "-.->" };
+
+/**
+ * A mermaid flowchart of the edges: a node per head with its name and
+ * address, a solid arrow for a call, a thick one for a table entry and a
+ * dotted one for a jump. The heads in `own` are drawn as rounded nodes.
+ */
+export function mermaidGraph(heads: readonly RoutineHead[], edges: readonly GraphEdge[], own: ReadonlySet<number> = new Set()): string {
+  const used = new Set(edges.flatMap((edge) => [edge.from, edge.to]));
+  for (const address of own) used.add(address);
+  const id = (address: number) => `n${address.toString(16).padStart(4, "0")}`;
+  const lines = ["flowchart LR"];
+  for (const head of heads) {
+    if (!used.has(head.address)) continue;
+    const label = `${head.name}<br/>${formatC64Address(head.address).toUpperCase()}`;
+    lines.push(own.has(head.address) ? `  ${id(head.address)}("${label}")` : `  ${id(head.address)}["${label}"]`);
+  }
+  for (const edge of edges) lines.push(`  ${id(edge.from)} ${ARROWS[edge.kind]} ${id(edge.to)}`);
+  return lines.join("\n");
+}

package/src/knowledge/history.ts

@@ -6,53 +6,72 @@ import type { DatabaseSync } from "node:sqlite";
 import { KnowledgeError } from "./database.ts";
 import {
   COMMENT_COLUMNS,
+  MACRO_COLUMNS,
+  MACRO_USE_COLUMNS,
   MODULE_COLUMNS,
+  OPERAND_COLUMNS,
+  PATCH_COLUMNS,
   REFERENCE_COLUMNS,
   REGION_COLUMNS,
+  resolveRevision,
   SUPPRESSION_COLUMNS,
   SYMBOL_COLUMNS,
   toComment,
+  toMacro,
+  toMacroUse,
   toModule,
+  toOperand,
+  toPatch,
   toReference,
   toRegion,
   toSuppression,
   toSymbol,
   type CommentRow,
+  type MacroRow,
+  type MacroUseRow,
   type ModuleRow,
+  type OperandRow,
+  type PatchRow,
   type ReferenceRow,
   type RegionRow,
   type SuppressionRow,
   type SymbolRow,
 } from "./read.ts";
 import { DEFAULT_SPACE, type EvidenceKind, type Origin, type Space } from "./schema.ts";
+import { compareText } from "./text.ts";
 import type { Evidence } from "./write.ts";
 
 export interface Revision {
-  id: number;
+  id: string;
   createdAt: string;
   origin: Origin;
   operation: string;
   description?: string;
   inputHash?: string;
   toolVersion?: string;
-  /** What the change rests on (D42). */
+  /** What the change rests on. */
   evidence?: Evidence[];
 }
 
 /** One knowledge row with its validity: from its first revision until the revision that closed it. */
 export type HistoryEntry =
-  | { entity: "symbol"; row: SymbolRow; from: number; to?: number }
-  | { entity: "region"; row: RegionRow; from: number; to?: number }
-  | { entity: "comment"; row: CommentRow; from: number; to?: number }
-  | { entity: "reference"; row: ReferenceRow; from: number; to?: number }
-  | { entity: "suppression"; row: SuppressionRow; from: number; to?: number }
-  | { entity: "module"; row: ModuleRow; from: number; to?: number };
+  | { entity: "symbol"; row: SymbolRow; from: string; to?: string }
+  | { entity: "analyzer-name"; row: SymbolRow; from: string; to?: string }
+  | { entity: "region"; row: RegionRow; from: string; to?: string }
+  | { entity: "comment"; row: CommentRow; from: string; to?: string }
+  | { entity: "reference"; row: ReferenceRow; from: string; to?: string }
+  | { entity: "suppression"; row: SuppressionRow; from: string; to?: string }
+  | { entity: "module"; row: ModuleRow; from: string; to?: string }
+  | { entity: "operand"; row: OperandRow; from: string; to?: string }
+  | { entity: "patch"; row: PatchRow; from: string; to?: string }
+  | { entity: "macro"; row: MacroRow; from: string; to?: string }
+  | { entity: "macro-use"; row: MacroUseRow; from: string; to?: string };
 
 type Raw = Record<string, unknown>;
 
 function toRevision(row: Raw): Revision {
   const revision: Revision = {
-    id: row.id as number,
+    id: row.id as string,
     createdAt: row.created_at as string,
     origin: row.origin as Origin,
     operation: row.operation as string,
@@ -64,13 +83,14 @@ function toRevision(row: Raw): Revision {
 }
 
 function entry<E extends HistoryEntry["entity"]>(entity: E, row: unknown, raw: Raw): HistoryEntry {
-  const result = { entity, row, from: raw.valid_from_revision as number } as HistoryEntry;
-  if (raw.valid_to_revision !== null) result.to = raw.valid_to_revision as number;
+  const result = { entity, row, from: raw.valid_from_revision as string } as HistoryEntry;
+  if (raw.valid_to_revision !== null) result.to = raw.valid_to_revision as string;
   return result;
 }
 
+/** Revision ids sort in time order as text; a current row sorts after every closed one. */
 function bySequence(a: HistoryEntry, b: HistoryEntry): number {
-  return a.from - b.from || (a.to ?? Infinity) - (b.to ?? Infinity);
+  return compareText(a.from, b.from) || compareText(a.to ?? "~", b.to ?? "~");
 }
 
 /** Every row, current or closed, that concerns one address of a space, oldest first. */
@@ -79,6 +99,7 @@ export function historyAt(db: DatabaseSync | undefined, address: number, space:
   const validity = ", valid_to_revision";
   const entries: HistoryEntry[] = [];
   for (const raw of db.prepare(`SELECT ${SYMBOL_COLUMNS}${validity} FROM symbols WHERE space = ? AND address = ?`).all(space, address) as Raw[]) entries.push(entry("symbol", toSymbol(raw), raw));
+  for (const raw of db.prepare(`SELECT ${SYMBOL_COLUMNS}${validity} FROM analyzer_names WHERE space = ? AND address = ?`).all(space, address) as Raw[]) entries.push(entry("analyzer-name", toSymbol(raw), raw));
   for (const raw of db.prepare(`SELECT ${REGION_COLUMNS}${validity} FROM regions WHERE space = ? AND start_address <= ? AND end_address >= ?`).all(space, address, address) as Raw[]) {
     entries.push(entry("region", toRegion(raw), raw));
   }
@@ -92,9 +113,24 @@ export function historyAt(db: DatabaseSync | undefined, address: number, space:
     entries.push(entry("suppression", toSuppression(raw), raw));
   }
   for (const raw of db.prepare(`SELECT ${MODULE_COLUMNS}${validity} FROM modules WHERE space = ? AND start_address = ?`).all(space, address) as Raw[]) entries.push(entry("module", toModule(raw), raw));
+  for (const raw of db.prepare(`SELECT ${OPERAND_COLUMNS}${validity} FROM operands WHERE space = ? AND address = ?`).all(space, address) as Raw[]) entries.push(entry("operand", toOperand(raw), raw));
+  for (const raw of db.prepare(`SELECT ${PATCH_COLUMNS}${validity} FROM patches WHERE space = ? AND start_address <= ? AND end_address >= ?`).all(space, address, address) as Raw[]) {
+    entries.push(entry("patch", toPatch(raw), raw));
+  }
+  for (const raw of db.prepare(`SELECT ${MACRO_USE_COLUMNS}${validity} FROM macro_uses WHERE space = ? AND start_address <= ? AND end_address >= ?`).all(space, address, address) as Raw[]) {
+    entries.push(entry("macro-use", toMacroUse(raw), raw));
+  }
   return entries.sort(bySequence);
 }
 
+/** Every row of a macro with this name, and every use of it, oldest first. */
+export function historyOfMacro(db: DatabaseSync | undefined, name: string, space: Space = DEFAULT_SPACE): HistoryEntry[] {
+  if (db === undefined) return [];
+  const macros = (db.prepare(`SELECT ${MACRO_COLUMNS}, valid_to_revision FROM macros WHERE space = ? AND name = ?`).all(space, name) as Raw[]).map((raw) => entry("macro", toMacro(raw), raw));
+  const uses = (db.prepare(`SELECT ${MACRO_USE_COLUMNS}, valid_to_revision FROM macro_uses WHERE space = ? AND macro = ?`).all(space, name) as Raw[]).map((raw) => entry("macro-use", toMacroUse(raw), raw));
+  return [...macros, ...uses].sort(bySequence);
+}
+
 /** Every symbol row of a space that ever had this name, oldest first: a name can move between addresses. */
 export function historyNamed(db: DatabaseSync | undefined, name: string, space: Space = DEFAULT_SPACE): HistoryEntry[] {
   if (db === undefined) return [];
@@ -104,7 +140,7 @@ export function historyNamed(db: DatabaseSync | undefined, name: string, space:
 }
 
 /** Why a revision was written and what it rests on: its description and its evidence, when it has them. */
-export function revisionNote(db: DatabaseSync | undefined, id: number): { reason?: string; evidence?: Evidence[] } {
+export function revisionNote(db: DatabaseSync | undefined, id: string): { reason?: string; evidence?: Evidence[] } {
   const raw = db?.prepare("SELECT * FROM revisions WHERE id = ?").get(id) as Raw | undefined;
   if (db === undefined || raw === undefined) return {};
   const { description, evidence } = withEvidence(db, toRevision(raw));
@@ -113,20 +149,25 @@ export function revisionNote(db: DatabaseSync | undefined, id: number): { reason
 
 /** The revision with its evidence, when it has any. */
 function withEvidence(db: DatabaseSync, revision: Revision): Revision {
-  const rows = db.prepare("SELECT kind, ref, sha256 FROM evidence WHERE revision = ? ORDER BY id").all(revision.id) as Raw[];
+  const rows = db.prepare("SELECT kind, ref, sha256, space FROM evidence WHERE revision = ? ORDER BY id").all(revision.id) as Raw[];
   if (rows.length === 0) return revision;
-  const evidence = rows.map((row): Evidence => ({ kind: row.kind as EvidenceKind, ref: row.ref as string, ...(row.sha256 === null ? {} : { sha256: row.sha256 as string }) }));
+  const evidence = rows.map((row): Evidence => ({
+    kind: row.kind as EvidenceKind,
+    ref: row.ref as string,
+    ...(row.sha256 === null ? {} : { sha256: row.sha256 as string }),
+    ...(row.space === null ? {} : { space: row.space as Space }),
+  }));
   return { ...revision, evidence };
 }
 
 /** Revisions, newest first; with `before`, only revisions older than it. */
-export function revisions(db: DatabaseSync | undefined, options: { limit?: number; before?: number } = {}): Revision[] {
+export function revisions(db: DatabaseSync | undefined, options: { limit?: number; before?: string } = {}): Revision[] {
   if (db === undefined) return [];
-  return (
-    db
-      .prepare("SELECT * FROM revisions WHERE id < ? ORDER BY id DESC LIMIT ?")
-      .all(options.before ?? Number.MAX_SAFE_INTEGER, options.limit ?? 50) as Raw[]
-  ).map((row) => withEvidence(db, toRevision(row)));
+  const rows =
+    options.before === undefined
+      ? db.prepare("SELECT * FROM revisions ORDER BY id DESC LIMIT ?").all(options.limit ?? 50)
+      : db.prepare("SELECT * FROM revisions WHERE id < ? ORDER BY id DESC LIMIT ?").all(resolveRevision(db, options.before), options.limit ?? 50);
+  return (rows as Raw[]).map((row) => withEvidence(db, toRevision(row)));
 }
 
 export interface RevisionChanges {
@@ -138,16 +179,22 @@ export interface RevisionChanges {
 }
 
 /** One revision and exactly what it changed. */
-export function revision(db: DatabaseSync | undefined, id: number): RevisionChanges {
+export function revision(db: DatabaseSync | undefined, text: string): RevisionChanges {
+  const id = resolveRevision(db, text);
   const raw = db?.prepare("SELECT * FROM revisions WHERE id = ?").get(id) as Raw | undefined;
   if (db === undefined || raw === undefined) throw new KnowledgeError("not-found", `There is no revision ${id}.`);
   const tables = [
     ["symbol", "symbols", SYMBOL_COLUMNS, toSymbol],
+    ["analyzer-name", "analyzer_names", SYMBOL_COLUMNS, toSymbol],
     ["region", "regions", REGION_COLUMNS, toRegion],
     ["comment", "comments", COMMENT_COLUMNS, toComment],
     ["reference", '"references"', REFERENCE_COLUMNS, toReference],
     ["suppression", "suppressions", SUPPRESSION_COLUMNS, toSuppression],
     ["module", "modules", MODULE_COLUMNS, toModule],
+    ["operand", "operands", OPERAND_COLUMNS, toOperand],
+    ["patch", "patches", PATCH_COLUMNS, toPatch],
+    ["macro", "macros", MACRO_COLUMNS, toMacro],
+    ["macro-use", "macro_uses", MACRO_USE_COLUMNS, toMacroUse],
   ] as const;
   const added: HistoryEntry[] = [];
   const closed: HistoryEntry[] = [];
@@ -161,3 +208,4 @@ export function revision(db: DatabaseSync | undefined, id: number): RevisionChan
   }
   return { revision: withEvidence(db, toRevision(raw)), added, closed };
 }
+