@printpractical/cruze 0.0.13 → 0.0.15

package/src/domain/edits/progress_block.ts

@@ -1,33 +0,0 @@
-import { MANAGED_CLOSE, MANAGED_OPEN, parseMarkdown } from "../markdown.ts";
-import { readTasks } from "../project/plan_parts.ts";
-import { progressRange, readProgress, type Progress } from "../project/progress.ts";
-
-/** Rewrites the managed `## Progress` block of a feature or change from a changed Progress. */
-export function updateProgress(text: string, change: (progress: Progress) => void): string {
-  const doc = parseMarkdown(text);
-  const progress = readProgress(doc);
-  for (const task of readTasks(doc).tasks) if (!progress.tasks.has(task.number)) progress.tasks.set(task.number, null);
-  change(progress);
-  const block = [MANAGED_OPEN, "## Progress", ...renderProgress(progress), MANAGED_CLOSE];
-  const range = progressRange(doc);
-  const lines = [...doc.lines];
-  if (range === null) {
-    while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
-    return [...lines, "", ...block, ""].join("\n");
-  }
-  lines.splice(range.open, range.end - range.open + 1, ...block);
-  return lines.join("\n");
-}
-
-function renderProgress(progress: Progress): string[] {
-  const lines: string[] = [];
-  if (progress.branch !== undefined) lines.push(`- Branch: ${progress.branch}`);
-  for (const [change, state] of progress.changes) lines.push(`- ${change}: ${state}`);
-  const ordered = [...progress.tasks].sort(([a], [b]) => Number(a.slice(1)) - Number(b.slice(1)));
-  for (const [task, commit] of ordered) {
-    lines.push(commit === null ? `- [ ] ${task}` : commit === "" ? `- [x] ${task}` : `- [x] ${task} (${commit})`);
-  }
-  for (const deviation of progress.deviations) lines.push(`- Deviation ${deviation}`);
-  if (progress.landed !== undefined) lines.push(`- Landed: ${progress.landed}`);
-  return lines;
-}

package/src/domain/edits/status_lines.ts

@@ -1,52 +0,0 @@
-import { headingElements, isStatusLine, statusOf, type Status } from "../elements.ts";
-import { STATUS_KINDS } from "../ids.ts";
-import { parseMarkdown, type MarkdownDoc } from "../markdown.ts";
-
-/** Managed `- Status:` lines: only the CLI adds or changes them. */
-
-/** Sets one element's status, adding the line after its facts when it has none. Returns the new text. */
-export function setStatus(text: string, id: string, status: Status): string {
-  const doc = parseMarkdown(text);
-  const element = headingElements(doc).find((e) => e.id === id);
-  if (element === undefined) throw new Error(`${id} is not in this document`);
-  const lines = [...doc.lines];
-  const at = statusLineIndex(doc, element.start, element.end);
-  if (at !== null) lines[at] = `- Status: ${status}`;
-  else lines.splice(insertionPoint(doc, element.start, element.end), 0, `- Status: ${status}`);
-  return lines.join("\n");
-}
-
-/** Adds `- Status: planned` to every status-carrying element that has none. */
-export function stampMissingStatuses(text: string): { text: string; stamped: string[] } {
-  let current = text;
-  const stamped: string[] = [];
-  for (const element of headingElements(parseMarkdown(text))) {
-    if (!STATUS_KINDS.includes(element.kind)) continue;
-    const doc = parseMarkdown(current);
-    const fresh = headingElements(doc).find((e) => e.id === element.id);
-    if (fresh === undefined || statusOf(doc, fresh) !== undefined) continue;
-    current = setStatus(current, element.id, "planned");
-    stamped.push(element.id);
-  }
-  return { text: current, stamped };
-}
-
-function statusLineIndex(doc: MarkdownDoc, start: number, end: number): number | null {
-  for (let i = start + 1; i < end; i++) {
-    if (!doc.inFence[i] && /^#{1,6} /.test(doc.lines[i] ?? "")) return null;
-    if (!doc.inFence[i] && isStatusLine(doc.lines[i] ?? "")) return i;
-  }
-  return null;
-}
-
-/** After the element's last top-level fact or step, before any diagram or nested heading. */
-function insertionPoint(doc: MarkdownDoc, start: number, end: number): number {
-  let point = start + 1;
-  for (let i = start + 1; i < end; i++) {
-    const line = doc.lines[i] ?? "";
-    if (doc.inFence[i] || /^#{1,6} /.test(line)) break;
-    if (/^(- |\s{2,}- )/.test(line)) point = i + 1;
-    else if (line.trim() !== "" && point > start + 1) break;
-  }
-  return point;
-}

package/src/domain/elements.ts

@@ -1,126 +0,0 @@
-import { ID_PATTERN, STATUS_KINDS, kindOf, type Kind } from "./ids.ts";
-import { sectionEnd, type MarkdownDoc } from "./markdown.ts";
-
-export type DeltaOp = "ADDED" | "MODIFIED" | "REMOVED";
-export type Status = "planned" | "built";
-
-/** One element: a heading `<ID>: <Title>` and its body, or a table row whose first cell is an ID. */
-export interface Element {
-  id: string;
-  kind: Kind;
-  title: string;
-  form: "heading" | "row";
-  /** Set when the heading is a delta operation, such as `### ADDED PORT-x: Title`. */
-  op?: DeltaOp;
-  level: number;
-  /** Line range [start, end) in the document. */
-  start: number;
-  end: number;
-}
-
-/** A delta heading that creates a spec file: `### ADDED CAPABILITY <name>: <Title>`. */
-export interface CapabilityOp {
-  capability: string;
-  title: string;
-  start: number;
-  end: number;
-}
-
-const HEADING = new RegExp(`^(?:(ADDED|MODIFIED|REMOVED) )?(${ID_PATTERN}): (.+)$`);
-const CAPABILITY = /^ADDED CAPABILITY ([a-z0-9]+(?:-[a-z0-9]+)*): (.+)$/;
-const ROW = new RegExp(`^\\|\\s*(${ID_PATTERN})\\s*\\|(.*)\\|\\s*$`);
-const STATUS_LINE = /^- Status: (planned|built)\s*$/;
-
-/** Heading elements whose heading lies in [from, to). */
-export function headingElements(doc: MarkdownDoc, from = 0, to = doc.lines.length): Element[] {
-  const elements: Element[] = [];
-  for (const heading of doc.headings) {
-    if (heading.line < from || heading.line >= to) continue;
-    const match = HEADING.exec(heading.text);
-    if (match?.[2] === undefined || match[3] === undefined) continue;
-    const element: Element = {
-      id: match[2],
-      kind: kindOf(match[2]),
-      title: match[3],
-      form: "heading",
-      level: heading.level,
-      start: heading.line,
-      end: Math.min(sectionEnd(doc, heading), to),
-    };
-    if (match[1] !== undefined) element.op = match[1] as DeltaOp;
-    elements.push(element);
-  }
-  return elements;
-}
-
-export function capabilityOps(doc: MarkdownDoc, from = 0, to = doc.lines.length): CapabilityOp[] {
-  return doc.headings
-    .filter((h) => h.line >= from && h.line < to)
-    .flatMap((heading) => {
-      const match = CAPABILITY.exec(heading.text);
-      if (match?.[1] === undefined || match[2] === undefined) return [];
-      return [{ capability: match[1], title: match[2], start: heading.line, end: Math.min(sectionEnd(doc, heading), to) }];
-    });
-}
-
-/** Row elements: table rows, outside code fences, whose first cell is an ID. */
-export function rowElements(doc: MarkdownDoc): Element[] {
-  return doc.lines.flatMap((line, index) => {
-    if (doc.inFence[index]) return [];
-    const match = ROW.exec(line);
-    if (match?.[1] === undefined) return [];
-    const title = match[2]?.split("|")[0]?.trim() ?? "";
-    return [{ id: match[1], kind: kindOf(match[1]), title, form: "row" as const, level: 0, start: index, end: index + 1 }];
-  });
-}
-
-export function elementLines(doc: MarkdownDoc, element: { start: number; end: number }): string[] {
-  return doc.lines.slice(element.start, element.end);
-}
-
-export function isStatusLine(line: string): boolean {
-  return STATUS_LINE.test(line);
-}
-
-/** The element's own managed status: the first status line before any nested heading. */
-/**
- * Whether an element is still to be built: marked `planned`, or a kind that carries a status
- * but not stamped yet, because the document holding it has never been approved.
- */
-export function isUnbuilt(doc: MarkdownDoc, element: Element): boolean {
-  const status = statusOf(doc, element);
-  return status === "planned" || (status === undefined && STATUS_KINDS.includes(element.kind));
-}
-
-export function statusOf(doc: MarkdownDoc, element: Element): Status | undefined {
-  for (let i = element.start + 1; i < element.end; i++) {
-    if (/^#{1,6} /.test(doc.lines[i] ?? "") && !doc.inFence[i]) return undefined;
-    const match = STATUS_LINE.exec(doc.lines[i] ?? "");
-    if (match?.[1] !== undefined) return match[1] as Status;
-  }
-  return undefined;
-}
-
-/**
- * The element's top-level facts: `- Key: value` items and their indented sub-items.
- * Nested elements' facts are excluded.
- */
-export function factsOf(doc: MarkdownDoc, element: Element): Map<string, string[]> {
-  const facts = new Map<string, string[]>();
-  let current: string[] | null = null;
-  for (let i = element.start + 1; i < element.end; i++) {
-    const line = doc.lines[i] ?? "";
-    if (doc.inFence[i]) continue;
-    if (/^#{1,6} /.test(line)) break;
-    const fact = /^- ([A-Z][A-Za-z ]*): ?(.*)$/.exec(line);
-    if (fact?.[1] !== undefined) {
-      current = fact[2] === undefined || fact[2] === "" ? [] : [fact[2]];
-      facts.set(fact[1], current);
-      continue;
-    }
-    const sub = /^\s{2,}- (.+)$/.exec(line);
-    if (sub?.[1] !== undefined && current !== null) current.push(sub[1]);
-    else if (line.trim() !== "") current = null;
-  }
-  return facts;
-}

package/src/domain/journal.ts

@@ -1,109 +0,0 @@
-/** The append-only journal: one JSON object per line, written only by the CLI. */
-
-export interface JournalEntry {
-  at: string;
-  event: string;
-  by: string;
-  [field: string]: unknown;
-}
-
-/** Events other tools and skills record, with the fields each requires. */
-export const RECORDED_EVENTS: Record<string, string[]> = {
-  rethink: ["level", "kind", "summary", "wrong", "found_by"],
-  disposition: ["finding", "disposition", "reason", "review"],
-  review: ["review", "round", "blockers", "concerns"],
-  override: ["gate", "reason"],
-  bug: ["summary", "cause"],
-  verification: ["result", "summary"],
-  checks: ["commit"],
-  lesson: ["summary", "instead", "step"],
-};
-
-/** Fields an event may carry beyond its required ones, checked when present. A defect rethink must say which step missed it. */
-const OPTIONAL_FIELDS: Record<string, string[]> = {
-  rethink: ["missed_by"],
-  review: ["nits", "checked_by"],
-  disposition: ["decided"],
-  verification: ["back_to", "commit"],
-};
-
-/** The workflow steps and checks that find or miss a problem, so a retro can count them. */
-export const STEPS = ["envision", "architect", "research", "design-review", "walkthrough", "plan", "plan-review", "build", "code-review", "verify", "land", "realign", "improve", "validate", "check", "user"];
-
-export const FIELD_VALUES: Record<string, string[]> = {
-  level: ["task", "detail", "change", "feature", "architecture", "vision"],
-  kind: ["defect", "discovery"],
-  disposition: ["fixed", "waived", "deferred", "rejected", "rethink"],
-  decided: ["agent", "user"],
-  review: ["design", "plan", "code", "realign", "improve"],
-  result: ["accepted", "sent-back"],
-  back_to: ["build", "rethink"],
-  checked_by: ["agent", "reviewer"],
-  found_by: STEPS,
-  missed_by: STEPS,
-  step: STEPS,
-};
-
-/** A defect rethink must say which step missed it, and a sent-back verification where the change goes back to. */
-function conditionallyRequired(event: string, fields: Record<string, string>): string[] {
-  if (event === "rethink" && fields["kind"] === "defect") return ["missed_by"];
-  if (event === "verification" && fields["result"] === "sent-back") return ["back_to"];
-  return [];
-}
-
-const CONDITION_NOTES: Record<string, string> = { missed_by: " for a defect", back_to: " when the change is sent back" };
-
-/** Fields recorded as numbers rather than text. */
-const COUNT_FIELDS = ["round", "blockers", "concerns", "nits"];
-
-export function journalPath(folder: string): string {
-  return `${folder}/journal.jsonl`;
-}
-
-export function parseJournal(text: string | undefined): { entries: JournalEntry[]; badLines: number[] } {
-  const entries: JournalEntry[] = [];
-  const badLines: number[] = [];
-  (text ?? "").split("\n").forEach((line, index) => {
-    if (line.trim() === "") return;
-    try {
-      const entry = JSON.parse(line) as JournalEntry;
-      if (typeof entry.event === "string" && typeof entry.at === "string") entries.push(entry);
-      else badLines.push(index + 1);
-    } catch {
-      badLines.push(index + 1);
-    }
-  });
-  return { entries, badLines };
-}
-
-export function serializeEntry(entry: JournalEntry): string {
-  return `${JSON.stringify(entry)}\n`;
-}
-
-/** Problems with an event a caller asks to record; empty when it can be recorded. */
-export function recordedEventProblems(event: string, fields: Record<string, string>): string[] {
-  const required = RECORDED_EVENTS[event];
-  if (required === undefined) return [`unknown event "${event}"; recordable events: ${Object.keys(RECORDED_EVENTS).join(", ")}`];
-  const needed = [...required, ...conditionallyRequired(event, fields)];
-  const problems = needed.filter((field) => (fields[field] ?? "").trim() === "").map((field) => `${event} needs ${field}${CONDITION_NOTES[field] ?? ""}`);
-  const known = [...required, ...(OPTIONAL_FIELDS[event] ?? [])];
-  for (const field of known) {
-    const value = fields[field];
-    if (value === undefined) continue;
-    const allowed = FIELD_VALUES[field];
-    if (allowed !== undefined && !allowed.includes(value)) problems.push(`${field} must be one of ${allowed.join(", ")}`);
-    if (COUNT_FIELDS.includes(field) && !/^\d+$/.test(value)) problems.push(`${field} must be a whole number`);
-  }
-  if ((event === "checks" || event === "verification") && fields["commit"] !== undefined && !/^[0-9a-f]{7,40}$/.test(fields["commit"])) {
-    problems.push("commit must be a commit hash, such as the output of git rev-parse --short HEAD");
-  }
-  if (event === "disposition" && fields["decided"] === "agent" && fields["disposition"] !== "fixed") {
-    problems.push("the agent decides only fixes; the user waives, defers or rejects a finding (decided=user)");
-  }
-  return problems;
-}
-
-/** The fields as the journal stores them: counts become numbers. */
-export function recordedFields(fields: Record<string, string>): Record<string, string | number> {
-  return Object.fromEntries(Object.entries(fields).map(([key, value]) => [key, COUNT_FIELDS.includes(key) ? Number(value) : value]));
-}

package/src/domain/land/bookkeeping.ts

@@ -1,54 +0,0 @@
-import { removeRow, upsertRow } from "../edits/managed_tables.ts";
-import { updateProgress } from "../edits/progress_block.ts";
-import { parseMarkdown } from "../markdown.ts";
-import { PATHS } from "../project/layout.ts";
-import { readChangesTable } from "../project/plan_parts.ts";
-import { readProgress } from "../project/progress.ts";
-import type { ProjectView } from "../project/project_view.ts";
-import type { WorkItem } from "../project/work_items.ts";
-
-export interface Bookkeeping {
-  /** Whether this land finishes the work: a standalone change, or a feature's last change. */
-  finished: boolean;
-  /** The folder to move into the archive when finished. */
-  archive?: { from: string; to: string };
-  release: string;
-}
-
-/** Records the land in progress blocks, the roadmap status and, when a feature finishes, the feature map. */
-export function applyBookkeeping(view: ProjectView, change: WorkItem, source: WorkItem, landed: string, files: Map<string, string>): Bookkeeping {
-  const text = (path: string): string | undefined => files.get(path) ?? view.snapshot.get(path);
-  files.set(change.path, updateProgress(text(change.path) ?? "", (progress) => (progress.landed = landed)));
-
-  let finished = true;
-  if (source !== change) {
-    const featureText = updateProgress(text(source.path) ?? "", (progress) => progress.changes.set(change.folderName, "landed"));
-    files.set(source.path, featureText);
-    const states = readProgress(parseMarkdown(featureText)).changes;
-    finished = readChangesTable(source.doc).every((row) => states.get(row.change) === "landed");
-  }
-
-  const release = releaseName(text(PATHS.roadmap));
-  const slug = typeof source.doc.frontmatter?.["roadmap"] === "string" ? source.doc.frontmatter["roadmap"] : undefined;
-  const roadmap = text(PATHS.roadmap);
-  if (slug !== undefined && roadmap !== undefined && roadmap.includes("## Status")) {
-    files.set(PATHS.roadmap, upsertRow(roadmap, "Status", [slug, source.folderName, finished ? "landed" : "building"]));
-  }
-  const vision = text(PATHS.vision);
-  if (finished && source.kind === "feature" && slug !== undefined && vision !== undefined && vision.includes("### Implemented")) {
-    const { text: withoutFuture, removed } = removeRow(vision, "Future", slug);
-    const summary = removed?.[1] ?? String(source.doc.frontmatter?.["title"] ?? slug);
-    files.set(PATHS.vision, upsertRow(withoutFuture, "Implemented", [slug, release, summary]));
-  }
-
-  const result: Bookkeeping = { finished, release };
-  if (finished) result.archive = { from: source.folder, to: `${PATHS.archiveDir}/${source.folderName}` };
-  return result;
-}
-
-/** The release in progress: the roadmap's `## Release` line up to its colon. */
-export function releaseName(roadmap: string | undefined): string {
-  if (roadmap === undefined) return "unreleased";
-  const line = roadmap.split("## Release")[1]?.split("\n").find((l) => l.trim() !== "");
-  return line?.split(":")[0]?.trim() || "unreleased";
-}

package/src/domain/land/merge_plan.ts

@@ -1,137 +0,0 @@
-import { settledIds } from "../approvals/rebase.ts";
-import { sectionForKind } from "../architecture_sections.ts";
-import { CruzeError } from "../cruze_error.ts";
-import { setStatus } from "../edits/status_lines.ts";
-import { headingElements, statusOf, type Element } from "../elements.ts";
-import { elementHash } from "../hashing.ts";
-import { STATUS_KINDS, kindOf, scopeOf } from "../ids.ts";
-import { findSection, parseMarkdown } from "../markdown.ts";
-import { readDelta, type DeltaEntry } from "../project/deltas.ts";
-import { PATHS, specPath } from "../project/layout.ts";
-import { readScope } from "../project/plan_parts.ts";
-import type { ProjectView } from "../project/project_view.ts";
-import type { WorkItem } from "../project/work_items.ts";
-import { REMOVED_MARK, capabilityKey } from "../validation/delta_rules.ts";
-import { appendBlock, relevel, removeElement, replaceElement } from "./text_ops.ts";
-
-export interface MergePlan {
-  /** New text of every living document the merge changes. */
-  files: Map<string, string>;
-  /** The work's merge record after this land: element ID to its merged hash. */
-  merged: Record<string, string>;
-  mergedIds: string[];
-  built: string[];
-  removed: string[];
-}
-
-/**
- * Merges a change's work into the living docs. The first change of a feature to land merges
- * the whole delta; elements it doesn't build arrive as planned, and later changes flip what
- * they build to built. Text is replaced only when nobody else changed it since this work merged it,
- * and an element merged and unchanged in the delta since keeps its living text, whoever edited it.
- */
-export function planMerge(view: ProjectView, change: WorkItem, source: WorkItem): MergePlan {
-  const scope = readScope(change.doc);
-  const inScope = new Set([...(scope?.delivers ?? []), ...(scope?.builds ?? [])]);
-  const delta = readDelta(source.doc);
-  const merged = { ...(view.approvals.get(source.folder)?.merged ?? {}) };
-  const files = new Map<string, string>();
-  const text = (path: string): string => files.get(path) ?? view.snapshot.get(path) ?? "";
-  const plan: MergePlan = { files, merged, mergedIds: [], built: [], removed: [] };
-  const settled = settledIds(source.doc, merged);
-
-  for (const op of delta.capabilities) {
-    const key = capabilityKey(op.capability);
-    if (merged[key] !== undefined || view.snapshot.has(specPath(op.capability))) continue;
-    const body = source.doc.lines.slice(op.start + 1, op.end).join("\n").trim();
-    files.set(specPath(op.capability), `# ${op.title}\n\n${body}\n`);
-    merged[key] = "created";
-  }
-
-  for (const entry of delta.entries) {
-    const { id } = entry.element;
-    const path = entry.section === "spec" ? specPath(scopeOf(id) ?? "") : PATHS.architecture;
-    if (entry.element.op === "REMOVED") {
-      if (scope?.removes.includes(id) === true) {
-        files.set(path, removeElement(text(path), id));
-        merged[id] = REMOVED_MARK;
-        plan.removed.push(id);
-      }
-      continue;
-    }
-    const kept = settled.has(id) && view.living.elements.has(id);
-    if (!kept) mergeEntry(view, source, entry, path, text, files, merged, plan);
-    for (const target of [entry.element, ...entry.scenarios].filter((e) => STATUS_KINDS.includes(e.kind))) {
-      if (kept && !inScope.has(target.id)) continue;
-      files.set(path, setStatus(text(path), target.id, statusAfterMerge(view, source, target, inScope)));
-      if (inScope.has(target.id)) plan.built.push(target.id);
-    }
-  }
-
-  for (const id of [...inScope].filter((id) => !delta.ids.has(id) && STATUS_KINDS.includes(kindOf(id)))) {
-    const living = view.living.elements.get(id);
-    if (living === undefined) continue;
-    files.set(living.path, setStatus(text(living.path), id, "built"));
-    plan.built.push(id);
-  }
-  verifyMerged(source, delta.entries, text, plan);
-  return plan;
-}
-
-function mergeEntry(
-  view: ProjectView,
-  source: WorkItem,
-  entry: DeltaEntry,
-  path: string,
-  text: (path: string) => string,
-  files: Map<string, string>,
-  merged: Record<string, string>,
-  plan: MergePlan,
-): void {
-  const { id } = entry.element;
-  const block = relevel(source.doc, entry.element.start, entry.element.end, entry.section === "spec" ? 2 : 3);
-  const deltaHash = elementHash(source.doc, entry.element);
-  const doc = parseMarkdown(text(path));
-  const living = headingElements(doc).find((e) => e.id === id);
-  const previous = merged[id];
-  if (living !== undefined) {
-    const livingHash = elementHash(doc, living);
-    if (previous !== undefined && previous !== REMOVED_MARK && livingHash !== previous) {
-      throw new CruzeError("merge-conflict", `${id} in ${path} changed since ${source.ref} merged it; rethink before landing`);
-    }
-    if (livingHash !== deltaHash) {
-      files.set(path, replaceElement(text(path), id, block));
-      plan.mergedIds.push(id);
-    }
-  } else {
-    if (previous !== undefined && previous !== REMOVED_MARK) {
-      throw new CruzeError("merge-conflict", `${id} was removed from ${path} after ${source.ref} merged it; rethink before landing`);
-    }
-    const section = entry.section === "spec" ? undefined : sectionForKind(entry.element.kind);
-    if (section !== undefined && findSection(doc, section) === null) throw new CruzeError("merge-conflict", `${path} has no "## ${section}" section for ${id}`);
-    files.set(path, appendBlock(text(path), block, section));
-    plan.mergedIds.push(id);
-  }
-  merged[id] = deltaHash;
-  for (const scenario of entry.scenarios) merged[scenario.id] = elementHash(source.doc, scenario);
-}
-
-/** Built when this change builds it, or when it was built and its text is unchanged; planned otherwise. */
-function statusAfterMerge(view: ProjectView, source: WorkItem, target: Element, inScope: Set<string>): "planned" | "built" {
-  if (inScope.has(target.id)) return "built";
-  const before = view.living.elements.get(target.id);
-  if (before === undefined || statusOf(before.doc, before.element) !== "built") return "planned";
-  return elementHash(before.doc, before.element) === elementHash(source.doc, target) ? "built" : "planned";
-}
-
-/** After merging, every merged element must hash exactly as it did in the delta. */
-function verifyMerged(source: WorkItem, entries: DeltaEntry[], text: (path: string) => string, plan: MergePlan): void {
-  for (const entry of entries.filter((e) => plan.mergedIds.includes(e.element.id))) {
-    const path = entry.section === "spec" ? specPath(scopeOf(entry.element.id) ?? "") : PATHS.architecture;
-    const doc = parseMarkdown(text(path));
-    const living = headingElements(doc).find((e) => e.id === entry.element.id);
-    if (living === undefined || elementHash(doc, living) !== elementHash(source.doc, entry.element)) {
-      throw new Error(`merge check failed: ${entry.element.id} in ${path} does not match the delta`);
-    }
-  }
-}

package/src/domain/land/text_ops.ts

@@ -1,66 +0,0 @@
-import { headingElements, isStatusLine } from "../elements.ts";
-import { parseMarkdown, type MarkdownDoc } from "../markdown.ts";
-
-/** Line-level edits land makes to living documents. Every function takes and returns whole text. */
-
-/**
- * A delta block ready for a living document: headings shifted so the element's own heading
- * sits at `level`, the operation prefix dropped, status lines removed, trailing blanks trimmed.
- */
-export function relevel(doc: MarkdownDoc, start: number, end: number, level: number): string[] {
-  const own = /^(#{1,6}) /.exec(doc.lines[start] ?? "")?.[1]?.length ?? level;
-  const shift = level - own;
-  const out: string[] = [];
-  for (let i = start; i < end; i++) {
-    let line = doc.lines[i] ?? "";
-    if (!doc.inFence[i]) {
-      if (isStatusLine(line)) continue;
-      const heading = /^(#{1,6}) (.*)$/.exec(line);
-      if (heading?.[1] !== undefined && heading[2] !== undefined) {
-        const text = i === start ? heading[2].replace(/^(ADDED|MODIFIED|REMOVED) /, "") : heading[2];
-        line = `${"#".repeat(heading[1].length + shift)} ${text}`;
-      }
-    }
-    out.push(line);
-  }
-  while (out.length > 0 && out[out.length - 1]?.trim() === "") out.pop();
-  return out;
-}
-
-/** Replaces an element's whole block, keeping one blank line before whatever follows. */
-export function replaceElement(text: string, id: string, block: string[]): string {
-  const doc = parseMarkdown(text);
-  const element = headingElements(doc).find((e) => e.id === id);
-  if (element === undefined) throw new Error(`${id} is not in the document`);
-  const lines = [...doc.lines];
-  const follows = element.end < lines.length;
-  lines.splice(element.start, element.end - element.start, ...block, ...(follows ? [""] : []));
-  return lines.join("\n");
-}
-
-export function removeElement(text: string, id: string): string {
-  const doc = parseMarkdown(text);
-  const element = headingElements(doc).find((e) => e.id === id);
-  if (element === undefined) return text;
-  const lines = [...doc.lines];
-  lines.splice(element.start, element.end - element.start);
-  return lines.join("\n");
-}
-
-/** Appends a block at the end of a `##` section, or at the end of the document when none is named. */
-export function appendBlock(text: string, block: string[], section?: string): string {
-  const doc = parseMarkdown(text);
-  const lines = [...doc.lines];
-  let at = lines.length;
-  if (section !== undefined) {
-    const heading = doc.headings.find((h) => h.level === 2 && h.text === section);
-    if (heading === undefined) throw new Error(`the document has no "## ${section}" section`);
-    at = doc.headings.find((h) => h.line > heading.line && h.level <= 2)?.line ?? lines.length;
-  }
-  let insertAt = at;
-  while (insertAt > 0 && lines[insertAt - 1]?.trim() === "") insertAt--;
-  const trailing = at < lines.length ? [""] : [];
-  lines.splice(insertAt, at - insertAt, "", ...block, ...trailing);
-  const joined = lines.join("\n");
-  return joined.endsWith("\n") ? joined : `${joined}\n`;
-}

package/src/domain/line_diff.ts

@@ -1,56 +0,0 @@
-/**
- * A line diff of two texts as unified-diff lines: "  " for a kept line, "- " removed, "+ " added.
- * Only the changes and `context` kept lines around each are shown; "…" marks the lines left out.
- */
-export function lineDiff(before: string[], after: string[], context = 2): string[] {
-  const ops = diffOps(before, after);
-  const near = new Set<number>();
-  ops.forEach((op, i) => {
-    if (op.kind === " ") return;
-    for (let j = Math.max(0, i - context); j <= Math.min(ops.length - 1, i + context); j++) near.add(j);
-  });
-  const lines: string[] = [];
-  let skipped = false;
-  ops.forEach((op, i) => {
-    if (!near.has(i)) {
-      skipped = true;
-      return;
-    }
-    if (skipped && lines.length > 0) lines.push("…");
-    skipped = false;
-    lines.push(`${op.kind} ${op.line}`);
-  });
-  if (skipped && lines.length > 0) lines.push("…");
-  return lines;
-}
-
-interface Op {
-  kind: " " | "-" | "+";
-  line: string;
-}
-
-/** The edit script of a longest common subsequence: documents are small enough for the quadratic table. */
-function diffOps(a: string[], b: string[]): Op[] {
-  const width = b.length + 1;
-  const table = new Int32Array((a.length + 1) * width);
-  const at = (i: number, j: number): number => table[i * width + j] ?? 0;
-  for (let i = a.length - 1; i >= 0; i--) {
-    for (let j = b.length - 1; j >= 0; j--) {
-      table[i * width + j] = a[i] === b[j] ? at(i + 1, j + 1) + 1 : Math.max(at(i + 1, j), at(i, j + 1));
-    }
-  }
-  const ops: Op[] = [];
-  let i = 0;
-  let j = 0;
-  while (i < a.length || j < b.length) {
-    if (i < a.length && j < b.length && a[i] === b[j]) {
-      ops.push({ kind: " ", line: a[i++] ?? "" });
-      j++;
-    } else if (j >= b.length || (i < a.length && at(i + 1, j) >= at(i, j + 1))) {
-      ops.push({ kind: "-", line: a[i++] ?? "" });
-    } else {
-      ops.push({ kind: "+", line: b[j++] ?? "" });
-    }
-  }
-  return ops;
-}