@printpractical/cruze 0.0.13 → 0.0.15

package/dist/app/use_cases/realign_status.js

@@ -1,106 +0,0 @@
-import { CruzeError } from "../../domain/cruze_error.js";
-                                                          
-import { PATHS } from "../../domain/project/layout.js";
-                                                                        
-import { validateProject } from "../../domain/validation/validate_project.js";
-import { notesBetween, parseRealignNotes,                  } from "../../domain/versions/realign_notes.js";
-import { FIRST_RELEASE } from "../../domain/versions/rule_versions.js";
-                                                 
-import { loadView,                  } from "../project_context.js";
-import { checkCode } from "./check_code.js";
-
-export const REALIGN_SKILL = "realign";
-
-                                 
-               
-                
-                  
-                                                             
-                  
- 
-
-                                                        
-                                                                        
-                             
- 
-
-                                
-                                                                                 
-                    
-                 
-                
-                                                                                                              
-                             
-                                                                          
-                        
-                                            
-               
- 
-
-/**
- * What realigning the project to its installed Cruze involves: the notes of every release
- * since `standards:`, or of all releases with `full`, and what their CLI rules find now.
- */
-export async function realignStatus(deps             , options                   )                         {
-  const view = await loadView(deps.files);
-  const config = requireInstalled(view, deps.bundle.version);
-  const standards = config.standards ?? FIRST_RELEASE;
-  const target = deps.bundle.version;
-  const notes = notesBetween(await bundledNotes(deps.bundle), options.full ? "0.0.0" : standards, target);
-  const waived = waivedFindings(view);
-  const check = (await checkCode(deps, { ci: false })).findings;
-  const problems = validateProject(view);
-  const report = notes.filter((n) => n.appliesTo === "existing").map((note)                    => {
-    const [command, rule] = (note.detect ?? ":").split(":");
-    const found = command === "check" ? check.filter((f) => f.rule === rule) : command === "validate" ? problems.filter((p) => p.rule === rule) : [];
-    const findings = found.map((f) => ({
-      path: f.path,
-      ...(f.line === undefined ? {} : { line: f.line }),
-      message: f.message,
-      // A check finding is waived by listing the file under check.exceptions, which also keeps CI green.
-      waived: command === "validate" && waived.has(findingKey(note.id, f.path)),
-    }));
-    return { ...note, findings };
-  });
-  return {
-    standards,
-    target,
-    full: options.full,
-    notes: report,
-    newWorkOnly: notes.filter((n) => n.appliesTo === "new").map((n) => n.id),
-    open: report.flatMap((n) => n.findings).filter((f) => !f.waived).length,
-  };
-}
-
-/** The key a realign disposition records for a mechanical finding, so a waiver can be matched later. */
-export function findingKey(note        , path        )         {
-  return `${note}: ${path}`;
-}
-
-/** The project's config, once its skills come from this CLI; realign works from the installed notes. */
-export function requireInstalled(view             , version        )              {
-  const config = view.config?.config;
-  if (config === null || config === undefined) throw new CruzeError("config", `fix ${PATHS.config} first; run cruze validate for details`);
-  if (config.cruze !== version) {
-    throw new CruzeError("install-first", `the project's skills are from Cruze ${config.cruze ?? "an unrecorded version"}, and this CLI is ${version}; run cruze install first`);
-  }
-  return config;
-}
-
-async function bundledNotes(bundle        )                         {
-  const skill = (await bundle.skills()).find((s) => s.folder === REALIGN_SKILL);
-  return (skill?.files ?? [])
-    .flatMap((file) => {
-      const version = /^notes\/(\d+\.\d+\.\d+)\.md$/.exec(file.path)?.[1];
-      return version === undefined ? [] : parseRealignNotes(version, file.text).notes;
-    });
-}
-
-/** Findings earlier realigns waived, by key. */
-function waivedFindings(view             )              {
-  return new Set(
-    view.journal
-      .filter((e) => e.event === "disposition" && e["review"] === "realign" && e["disposition"] === "waived")
-      .map((e) => String(e["finding"])),
-  );
-}

package/dist/app/use_cases/record_progress.js

@@ -1,118 +0,0 @@
-import { CruzeError } from "../../domain/cruze_error.js";
-import { readRows, removeRow, upsertRow } from "../../domain/edits/managed_tables.js";
-import { updateProgress } from "../../domain/edits/progress_block.js";
-import { resolveChange } from "../../domain/project/artifact_ref.js";
-import { PATHS } from "../../domain/project/layout.js";
-import { readTasks } from "../../domain/project/plan_parts.js";
-import { requireSlug } from "../../domain/project/new_items.js";
-import { activeChange } from "../../domain/status/work_status.js";
-                                                                   
-import { appendJournal, loadView,                  } from "../project_context.js";
-
-/** Commands that write the CLI-owned progress records: task ticks, deviations and the feature map. */
-
-                             
-                 
-               
-               
-                
- 
-
-/** Marks a task done, recording the commit that completed it (HEAD by default). */
-export async function completeTask(deps             , task        , options                                      )                      {
-  const change = await changeFor(deps, options.change);
-  requireTask(change, task);
-  const commit = options.commit ?? (await deps.repository.headCommit()) ?? "";
-  const text = updateProgress(change.doc.lines.join("\n"), (progress) => progress.tasks.set(task, commit));
-  await deps.files.writeText(change.path, text);
-  const ticks = [...text.matchAll(/^- \[([ x])\] T\d+/gm)];
-  return { change: change.ref, task, done: ticks.filter((m) => m[1] === "x").length, total: ticks.length };
-}
-
-/** Reopens a done task whose design a rethink changed, so build does it again. */
-export async function reopenTask(deps             , task        , reason        , options                     )                                            {
-  const change = await changeFor(deps, options.change);
-  requireTask(change, task);
-  if (reason.trim() === "") throw new CruzeError("missing-reason", "say why the task reopens");
-  await deps.files.writeText(change.path, updateProgress(change.doc.lines.join("\n"), (progress) => progress.tasks.set(task, null)));
-  await appendJournal(deps, change.folder, "reopen", { change: change.ref, task, reason: reason.trim() });
-  return { change: change.ref, task };
-}
-
-/** Records a task-level choice the agent made on its own. Anything larger is a rethink. */
-export async function recordDeviation(deps             , task        , text        , options                     )                                            {
-  const change = await changeFor(deps, options.change);
-  requireTask(change, task);
-  if (text.trim() === "") throw new CruzeError("missing-text", "describe the deviation");
-  await deps.files.writeText(change.path, updateProgress(change.doc.lines.join("\n"), (progress) => progress.deviations.push(`${task}: ${text.trim()}`)));
-  await appendJournal(deps, change.folder, "deviation", { change: change.ref, task, text: text.trim() });
-  return { change: change.ref, task };
-}
-
-/** Adds a feature to the future list of the feature map, or replaces its entry. */
-export async function addFutureFeature(deps             , slug        , summary        , goals          )                               {
-  requireSlug(slug);
-  const vision = await requireVision(deps);
-  await deps.files.writeText(PATHS.vision, upsertRow(vision, "Future", [slug, summary, goals.join(", ")]));
-  await appendJournal(deps, ".cruze", "feature-map", { action: "add", feature: slug, summary, goals });
-  return { feature: slug };
-}
-
-/**
- * Replaces a feature's summary on the feature map, in the future list or the implemented list,
- * when a decision changed what the feature delivers. Its goals or release stay as they are.
- */
-export async function updateFeatureSummary(deps             , slug        , summary        )                                                               {
-  if (summary.trim() === "") throw new CruzeError("missing-summary", "a feature needs a summary");
-  const vision = await requireVision(deps);
-  const future = readRows(vision, "Future").find((row) => row[0] === slug);
-  const implemented = readRows(vision, "Implemented").find((row) => row[0] === slug);
-  if (future === undefined && implemented === undefined) throw new CruzeError("not-found", `${slug} is not on the feature map`);
-  const list = future !== undefined ? "Future" : "Implemented";
-  const cells = future !== undefined ? [slug, summary.trim(), future[2] ?? ""] : [slug, implemented?.[1] ?? "", summary.trim()];
-  await deps.files.writeText(PATHS.vision, upsertRow(vision, list, cells));
-  await appendJournal(deps, ".cruze", "feature-map", { action: "update", feature: slug, summary: summary.trim() });
-  return { feature: slug, list };
-}
-
-export async function dropFutureFeature(deps             , slug        , reason        )                               {
-  const vision = await requireVision(deps);
-  const { text, removed } = removeRow(vision, "Future", slug);
-  if (removed === null) throw new CruzeError("not-found", `${slug} is not on the future list`);
-  if (reason.trim() === "") throw new CruzeError("missing-reason", "dropping a feature needs a reason");
-  await deps.files.writeText(PATHS.vision, text);
-  await appendJournal(deps, ".cruze", "feature-map", { action: "drop", feature: slug, reason });
-  return { feature: slug };
-}
-
-/** Clears the landed rows from the roadmap's Status table, when a release closes. */
-export async function pruneRoadmap(deps             )                                 {
-  const roadmap = await deps.files.readText(PATHS.roadmap);
-  if (roadmap === undefined) throw new CruzeError("not-found", `${PATHS.roadmap} does not exist yet`);
-  const landed = readRows(roadmap, "Status").filter((row) => row[2] === "landed").map((row) => row[0] ?? "");
-  let text = roadmap;
-  for (const item of landed) text = removeRow(text, "Status", item).text;
-  if (landed.length > 0) {
-    await deps.files.writeText(PATHS.roadmap, text);
-    await appendJournal(deps, ".cruze", "roadmap-prune", { items: landed });
-  }
-  return { removed: landed };
-}
-
-async function changeFor(deps             , ref                    )                    {
-  const view = await loadView(deps.files);
-  if (ref !== undefined) return resolveChange(view, ref);
-  const change = activeChange(view, await deps.repository.currentBranch());
-  if (change === undefined) throw new CruzeError("no-active-change", "no change is bound to this branch; name one with --change");
-  return change;
-}
-
-function requireTask(change          , task        )       {
-  if (!readTasks(change.doc).tasks.some((t) => t.number === task)) throw new CruzeError("unknown-task", `${change.ref} has no task ${task}`);
-}
-
-async function requireVision(deps             )                  {
-  const vision = await deps.files.readText(PATHS.vision);
-  if (vision === undefined) throw new CruzeError("not-found", `${PATHS.vision} does not exist yet`);
-  return vision;
-}

package/dist/app/use_cases/show_elements.js

@@ -1,18 +0,0 @@
-import { CruzeError } from "../../domain/cruze_error.js";
-import { elementIndex, lookupElements,                   } from "../../domain/project/element_lookup.js";
-                                                                       
-import { loadView,                  } from "../project_context.js";
-
-/** The bodies of the named elements, living and in each in-flight delta that changes them. */
-export async function showElements(deps             , ids          )                                        {
-  const { elements, missing } = lookupElements(await loadView(deps.files), ids);
-  if (missing.length > 0) throw new CruzeError("unknown-id", `${missing.join(", ")} ${missing.length === 1 ? "is" : "are"} defined nowhere in the living docs or the work in flight; cruze show --index lists every element`);
-  return { elements };
-}
-
-/** One line per element of the living architecture and specs, with what work in flight adds or changes. */
-export async function showIndex(deps             , scope         )                                             {
-  const index = elementIndex(await loadView(deps.files), scope);
-  if (scope !== undefined && index.entries.length === 0) throw new CruzeError("unknown-scope", `no element belongs to "${scope}"; name a context or capability, such as the part of an ID before its dot`);
-  return scope === undefined ? index : { ...index, scope };
-}

package/dist/app/use_cases/show_notes.js

@@ -1,11 +0,0 @@
-import { notesFor, readNotes,                          } from "../../domain/project/notes.js";
-import { loadView,                  } from "../project_context.js";
-
-/**
- * Every note with what it is about and the hand-off it holds, or, given a target such as
- * `project`, `architect` or a feature slug, the notes and hand-off rows for it.
- */
-export async function showNotes(deps             , target         )                                                               {
-  const notes = readNotes((await loadView(deps.files)).snapshot);
-  return target === undefined ? { notes } : { target, ...notesFor(notes, [target]) };
-}

package/dist/app/use_cases/show_scope.js

@@ -1,51 +0,0 @@
-import { CruzeError } from "../../domain/cruze_error.js";
-import { resolveArtifact } from "../../domain/project/artifact_ref.js";
-import { scopeOf } from "../../domain/ids.js";
-import { notesFor, readNotes,               } from "../../domain/project/notes.js";
-import { scopeView,                } from "../../domain/project/scope_view.js";
-                                                                   
-import { loadView,                  } from "../project_context.js";
-import { listEvents } from "./journal_events.js";
-
-                              
-                  
-                      
-                 
-                 
- 
-
-                                                
-                                                                                                               
-                              
-                                                                                                        
-                                                   
-                                                                                   
-                  
- 
-
-/**
- * The design a change builds, or a feature's whole delta, with the elements it cites and the
- * item's settled ledger: what plan, build and the reviewers read instead of the whole living docs.
- */
-export async function showScope(deps             , ref        )                       {
-  const view = await loadView(deps.files);
-  const { item } = resolveArtifact(view, ref);
-  if (item === undefined) throw new CruzeError("not-work", `"${ref}" is not a feature or change; show takes a feature or change ID`);
-  const scope = scopeView(view, item);
-  const dispositions = (await listEvents(deps, "disposition", scope.feature ?? item.ref, true)).map((entry) => ({
-    finding: String(entry["finding"] ?? ""),
-    disposition: String(entry["disposition"] ?? ""),
-    reason: String(entry["reason"] ?? ""),
-    review: String(entry["review"] ?? ""),
-  }));
-  const feature = scope.feature === undefined ? item : (view.items.find((i) => i.ref === scope.feature) ?? item);
-  const contexts = [...scope.elements, ...scope.scenarios].flatMap((e) => scopeOf(e.id) ?? []);
-  const notes = notesFor(readNotes(view.snapshot), [...slugsOf(feature), ...contexts]);
-  return { ...scope, dispositions, references: view.config?.config?.references ?? [], notes };
-}
-
-/** The names a note or a hand-off may use for a feature or standalone change: its roadmap slug, and its folder name without the date. */
-export function slugsOf(item          )           {
-  const roadmap = item.doc.frontmatter?.["roadmap"];
-  return [...new Set([...(typeof roadmap === "string" ? [roadmap] : []), item.folderName.replace(/^\d{4}-\d{2}-\d{2}-/, "")])];
-}

package/dist/app/use_cases/upstream_diff.js

@@ -1,55 +0,0 @@
-import { evaluateApproval,                    } from "../../domain/approvals/evaluate.js";
-import { rebaseNeeded } from "../../domain/approvals/rebase.js";
-import { upstreamLines, upstreamPath } from "../../domain/approvals/upstream_text.js";
-import { lineDiff } from "../../domain/line_diff.js";
-import { resolveArtifact } from "../../domain/project/artifact_ref.js";
-import { approvalFolder, approvalsPath } from "../../domain/project/project_view.js";
-import { loadView,                  } from "../project_context.js";
-
-                                 
-                                                                         
-              
-                
-                                                                                      
-                  
-                
- 
-
-                                     
-                   
-               
-                       
-                            
-                                                                                                     
-                   
- 
-
-/**
- * What changed upstream of a document since its approval, element by element, so a person can
- * judge a re-stamp from the text rather than the IDs. The approved text comes from the commit
- * that recorded the approval. One project went to a rethink for two file-list merges that
- * changed no behaviour, because status named only the IDs.
- */
-export async function upstreamDiff(deps             , ref        )                              {
-  const view = await loadView(deps.files);
-  const { path, item } = resolveArtifact(view, ref);
-  const status = evaluateApproval(view, path);
-  const report                     = { artifact: path, state: status.state, changes: [], rebase: item === undefined ? [] : rebaseNeeded(view, item) };
-  if (item !== undefined) report.ref = item.ref;
-  const record = status.record;
-  if (record === undefined || status.changed.length === 0) return report;
-  const commit = await deps.repository.firstCommitAdding(approvalsPath(approvalFolder(view, path)), record.approvedAt);
-  for (const key of status.changed) {
-    const where = upstreamPath(view, key);
-    if (where === undefined) {
-      report.changes.push({ key, note: "it no longer exists" });
-      continue;
-    }
-    const now = upstreamLines(key, where, view.snapshot.get(where) ?? "") ?? [];
-    const then = commit === null ? null : await deps.repository.fileAt(commit, where);
-    const approved = then === null ? undefined : upstreamLines(key, where, then, record.upstream[key]);
-    if (approved !== undefined) report.changes.push({ key, path: where, diff: lineDiff(approved, now) });
-    else report.changes.push({ key, path: where, note: commit === null ? "the approval isn't committed yet; compare with git diff" : `its approved text isn't in ${where} at ${commit}, the commit that recorded the approval` });
-  }
-  return report;
-}

package/dist/domain/approvals/agent_approval.js

@@ -1,68 +0,0 @@
-import { CruzeError } from "../cruze_error.js";
-                                                  
-                                                         
-                                                    
-
-/**
- * Why an approval was given without the user: a plan whose review closed, or work that a
- * rethink left unchanged while something it cites moved. The user can still object, and
- * editing the document makes the approval stale as usual.
- */
-                                                   
-
-const byTime = (a              , b              )         => a.at.localeCompare(b.at);
-
-/**
- * A feature's change may be approved by the agent once its plan review has closed: a review
- * recorded since the change was last approved, no blocker left open in its last round, and a
- * disposition for every finding of its first round. The feature's design, and a standalone
- * change's, stay the user's to approve.
- */
-export function requirePlanReviewClosed(journal                , item          )       {
-  if (item.kind !== "change") {
-    throw new CruzeError("needs-user", `${item.ref} carries design, so the user approves it; only a feature's change can be approved after its plan review`);
-  }
-  const entries = journal.filter((e) => e["item"] === item.ref || e["artifact"] === item.path).sort(byTime);
-  const lastApproval = entries.filter((e) => e.event === "approve").at(-1);
-  const reviews = entries.filter((e) => e.event === "review" && e["review"] === "plan" && (lastApproval === undefined || e.at > lastApproval.at));
-  const last = reviews.at(-1);
-  if (last === undefined) {
-    const since = lastApproval === undefined ? "" : " since the change was last approved";
-    throw new CruzeError("plan-review-open", `no plan review is recorded for ${item.ref}${since}; run the plan review first`);
-  }
-  const blockers = Number(last["blockers"] ?? 0);
-  if (blockers > 0 && Number(last["round"]) === 1) {
-    throw new CruzeError("plan-review-open", `the plan review's round 1 found ${blockers} blocker(s); check their fixes in round 2`);
-  }
-  if (blockers > 0) {
-    throw new CruzeError("plan-review-open", `round 2 left ${blockers} blocker(s) open; the user decides them and approves the plan`);
-  }
-  const first = reviews.filter((e) => Number(e["round"]) === 1).at(-1) ?? last;
-  const findings = Number(first["blockers"] ?? 0) + Number(first["concerns"] ?? 0);
-  const decided = entries.filter((e) => e.event === "disposition" && e["review"] === "plan" && e.at > first.at).length;
-  if (decided < findings) {
-    throw new CruzeError("plan-review-open", `the plan review raised ${findings} finding(s) but ${decided} have a disposition; record one for each`);
-  }
-}
-
-/**
- * A rethink may re-approve, for the user, a feature or change it didn't edit: one whose own
- * design is unchanged and that is stale only because something it cites changed. A change
- * with a task reopened since its approval goes back to the user.
- */
-export function requireUnchangedSinceApproval(journal                , item                      , path        , status                )       {
-  if (item === undefined) {
-    throw new CruzeError("needs-user", `${path} is a project document, so the user re-approves it; a rethink re-stamps only features and changes`);
-  }
-  if (status.state === "edited") {
-    throw new CruzeError("needs-user", `${item.ref} itself changed since its approval, so the user re-approves it`);
-  }
-  if (status.state !== "upstream-changed") {
-    throw new CruzeError("not-stale", `${item.ref} is ${status.state}; only work whose upstream changed can be re-stamped`);
-  }
-  const approvedAt = journal.filter((e) => e.event === "approve" && e["artifact"] === path).sort(byTime).at(-1)?.at ?? "";
-  const reopened = journal.filter((e) => e.event === "reopen" && e["change"] === item.ref && e.at > approvedAt).map((e) => String(e["task"]));
-  if (reopened.length > 0) {
-    throw new CruzeError("needs-user", `${item.ref} had ${reopened.join(", ")} reopened since its approval, so the user re-approves it`);
-  }
-}

package/dist/domain/approvals/evaluate.js

@@ -1,36 +0,0 @@
-import { parseMarkdown } from "../markdown.js";
-import { approvalFolder,                  } from "../project/project_view.js";
-import { currentUpstreamHash, fingerprint } from "./fingerprint.js";
-import { latestApproval,                     } from "./records.js";
-
-                                                                                      
-
-                                 
-                   
-                       
-                                                                              
-                    
-                          
-                                                                           
-                        
- 
-
-/**
- * Computes an artifact's approval state from content, never from stored state:
- * editing an upstream document is all it takes to make downstream work stale.
- */
-export function evaluateApproval(view             , artifact        )                 {
-  const record = latestApproval(view.approvals.get(approvalFolder(view, artifact)) ?? { version: 1, approvals: [], merged: {} }, artifact);
-  if (record === undefined) return { artifact, state: "unapproved", changed: [] };
-  const journaled = view.journal.some((e) => e.event === "approve" && e.artifact === artifact && e.hash === record.hash);
-  if (!journaled) return { artifact, state: "unapproved", changed: [], record, unjournaled: true };
-
-  const text = view.snapshot.get(artifact);
-  if (text === undefined) return { artifact, state: "unapproved", changed: [], record };
-  const { hash } = fingerprint(view, artifact, parseMarkdown(text));
-  if (hash !== record.hash) return { artifact, state: "edited", changed: [], record };
-  const changed = Object.entries(record.upstream)
-    .filter(([key, pinned]) => currentUpstreamHash(view, key) !== pinned)
-    .map(([key]) => key);
-  return { artifact, state: changed.length > 0 ? "upstream-changed" : "approved", changed, record };
-}

package/dist/domain/approvals/fingerprint.js

@@ -1,52 +0,0 @@
-import { headingElements, rowElements } from "../elements.js";
-import { designHash, elementHash } from "../hashing.js";
-import { findIds } from "../ids.js";
-                                                  
-import { PATHS } from "../project/layout.js";
-                                                              
-import { featureOf } from "../project/work_items.js";
-
-/** What an approval pins: the document's design hash and the hash of everything upstream it relies on. */
-                              
-               
-                                   
- 
-
-/** Documents a person can approve. Specs, the glossary and ADRs change only through approved work. */
-export function isApprovable(view             , path        )          {
-  return [PATHS.vision, PATHS.architecture, PATHS.roadmap].includes(path         ) || view.items.some((i) => i.path === path && !i.archived);
-}
-
-export function fingerprint(view             , path        , doc             )              {
-  const upstream                         = {};
-  const ownIds = new Set([...headingElements(doc), ...rowElements(doc)].filter((e) => e.op !== "ADDED").map((e) => e.id));
-  const isLivingDoc = !view.items.some((item) => item.path === path);
-  const designText = doc.lines.filter((_, i) => !doc.inManaged[i]).join("\n");
-
-  for (const id of findIds(designText)) {
-    if (isLivingDoc && ownIds.has(id)) continue;
-    const living = view.living.elements.get(id);
-    if (living !== undefined) upstream[id] = elementHash(living.doc, living.element);
-  }
-  const item = view.items.find((i) => i.path === path);
-  if (item !== undefined) {
-    // Work always depends on the dependency rules, cited or not.
-    for (const [id, living] of view.living.elements) {
-      if (id.startsWith("RULE-")) upstream[id] = elementHash(living.doc, living.element);
-    }
-    const feature = item.kind === "change" ? featureOf(view.items, item) : undefined;
-    if (feature !== undefined) upstream[`doc:${feature.path}`] = designHash(feature.doc);
-  }
-  return { hash: designHash(doc), upstream };
-}
-
-/** The current hash of one upstream key, or undefined when it no longer exists. */
-export function currentUpstreamHash(view             , key        )                     {
-  if (key.startsWith("doc:")) {
-    const path = key.slice("doc:".length);
-    const item = view.items.find((i) => i.path === path);
-    return item === undefined ? undefined : designHash(item.doc);
-  }
-  const living = view.living.elements.get(key);
-  return living === undefined ? undefined : elementHash(living.doc, living.element);
-}

package/dist/domain/approvals/rebase.js

@@ -1,39 +0,0 @@
-import { elementHash } from "../hashing.js";
-                                                  
-import { readDelta } from "../project/deltas.js";
-import { approvalFolder,                  } from "../project/project_view.js";
-                                                         
-import { latestApproval } from "./records.js";
-
-/**
- * Delta elements a feature or standalone change merged and hasn't changed since. The merge did
- * their job, so the living text is the one to keep: an edit there by a rethink, a realign or
- * another land asks nothing of the delta. One project's delta went stale this way, and every
- * later edit of an element its first change had merged forced a rebase of text with no work left in it.
- */
-export function settledIds(doc             , merged                        )              {
-  const settled = new Set        ();
-  for (const entry of readDelta(doc).entries) {
-    for (const element of [entry.element, ...entry.scenarios]) {
-      if (merged[element.id] === elementHash(doc, element)) settled.add(element.id);
-    }
-  }
-  return settled;
-}
-
-/**
- * Elements the work's delta still changes whose living text moved since its last approval:
- * approving the delta as it stands would overwrite that edit. A change's own approval pins no delta.
- */
-export function rebaseNeeded(view             , item          )           {
-  if (item.kind === "change") return [];
-  const file = view.approvals.get(approvalFolder(view, item.path));
-  const previous = file === undefined ? undefined : latestApproval(file, item.path);
-  if (previous === undefined) return [];
-  const settled = settledIds(item.doc, file?.merged ?? {});
-  return [...readDelta(item.doc).ids].filter((id) => {
-    const living = view.living.elements.get(id);
-    const before = previous.upstream[id];
-    return !settled.has(id) && living !== undefined && before !== undefined && before !== elementHash(living.doc, living.element);
-  });
-}

package/dist/domain/approvals/records.js

@@ -1,50 +0,0 @@
-/** What `approvals.json` holds. Only the CLI writes it. */
-
-                                 
-                                       
-                   
-                                                   
-               
-                                                                                                  
-                                   
-                     
-             
-                                                                                   
-                 
- 
-
-                                
-             
-                              
-                                                                                          
-                                 
- 
-
-export function emptyApprovals()                {
-  return { version: 1, approvals: [], merged: {} };
-}
-
-export function parseApprovals(text                    )                                            {
-  if (text === undefined) return { file: emptyApprovals() };
-  try {
-    const raw = JSON.parse(text)                          ;
-    if (raw.version !== 1 || !Array.isArray(raw.approvals)) return { file: emptyApprovals(), problem: "approvals.json has an unknown format" };
-    return { file: { version: 1, approvals: raw.approvals, merged: raw.merged ?? {} } };
-  } catch {
-    return { file: emptyApprovals(), problem: "approvals.json is not valid JSON" };
-  }
-}
-
-export function serializeApprovals(file               )         {
-  return `${JSON.stringify(file, null, 2)}\n`;
-}
-
-/** The latest approval of an artifact, if any. */
-export function latestApproval(file               , artifact        )                             {
-  return file.approvals.filter((record) => record.artifact === artifact).at(-1);
-}
-
-/** Replaces the artifact's approval: one current approval per artifact; history lives in the journal. */
-export function withApproval(file               , record                )                {
-  return { ...file, approvals: [...file.approvals.filter((r) => r.artifact !== record.artifact), record] };
-}

package/dist/domain/approvals/upstream_text.js

@@ -1,36 +0,0 @@
-import { isStatusLine } from "../elements.js";
-import { designHash, elementHash } from "../hashing.js";
-import { parseMarkdown,                  } from "../markdown.js";
-import { buildLivingModel } from "../project/living_model.js";
-                                                              
-
-/** The document that holds an upstream key now: an element's living document, or the path of a `doc:` key. */
-export function upstreamPath(view             , key        )                     {
-  if (key.startsWith("doc:")) return view.snapshot.has(key.slice("doc:".length)) ? key.slice("doc:".length) : undefined;
-  return view.living.elements.get(key)?.path;
-}
-
-/**
- * The design lines behind an upstream key in one version of the document at `path`, without the
- * managed blocks and status lines no hash covers. With `pinned`, only when they hash as pinned.
- */
-export function upstreamLines(key        , path        , text        , pinned         )                       {
-  if (key.startsWith("doc:")) {
-    const doc = parseMarkdown(text);
-    if (pinned !== undefined && designHash(doc) !== pinned) return undefined;
-    return designLines(doc, 0, doc.lines.length);
-  }
-  const living = buildLivingModel(new Map([[path, text]])).elements.get(key);
-  if (living === undefined) return undefined;
-  if (pinned !== undefined && elementHash(living.doc, living.element) !== pinned) return undefined;
-  return designLines(living.doc, living.element.start, living.element.end);
-}
-
-function designLines(doc             , start        , end        )           {
-  const lines           = [];
-  for (let i = start; i < end; i++) {
-    const line = doc.lines[i] ?? "";
-    if (!doc.inManaged[i] && (doc.inFence[i] || !isStatusLine(line))) lines.push(line);
-  }
-  return lines;
-}