@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-7QAYL2RH.js

@@ -0,0 +1,555 @@
+import {
+  build_upgrade_command
+} from "./chunk-SWHN7TNT.js";
+import {
+  create_version_command_config
+} from "./chunk-SADJPNDB.js";
+import {
+  pr_classification
+} from "./chunk-CT773QBI.js";
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.js";
+import {
+  status_icons
+} from "./chunk-65E4OZJ7.js";
+import {
+  ls_remote_branch_arguments
+} from "./chunk-ZBFNQUY7.js";
+import {
+  OTHER_CHANGE_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  GATE_COMMAND
+} from "./chunk-TBIX5FRN.js";
+import {
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  git_location_environment,
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  GIT_TIMEOUT_MS,
+  SUITE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/propagate/propagate-git.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+var REMOTE_TIMEOUT_MS = 6e4;
+var DEFAULT_BRANCH_REF = "refs/remotes/origin/HEAD";
+var FALLBACK_DEFAULT_BRANCH = "main";
+var ORIGIN_PREFIX = "refs/remotes/origin/";
+var PRE_PUSH_HOOK = "pre-push";
+function run_git(repository_path, args, timeout_ms = GIT_TIMEOUT_MS) {
+  return git_spawn_sync.read(args, {
+    cwd: repository_path,
+    timeout: timeout_ms,
+    env: { ...git_spawn_sync.C_LOCALE, ...git_location_environment.location_free_environment() }
+  });
+}
+function default_branch(repository_path) {
+  const reference = run_git(repository_path, ["symbolic-ref", DEFAULT_BRANCH_REF]);
+  if (reference?.startsWith(ORIGIN_PREFIX) !== true) return FALLBACK_DEFAULT_BRANCH;
+  return reference.slice(ORIGIN_PREFIX.length);
+}
+function current_branch(repository_path) {
+  return run_git(repository_path, ["rev-parse", "--abbrev-ref", "HEAD"]);
+}
+function is_clean(repository_path) {
+  return run_git(repository_path, ["status", "--porcelain"]) === "";
+}
+function fetch_branch(repository_path, branch) {
+  run_git(repository_path, ["fetch", "--quiet", "origin", branch]);
+}
+function is_up_to_date(repository_path, branch) {
+  fetch_branch(repository_path, branch);
+  const local = run_git(repository_path, ["rev-parse", branch]);
+  const remote = run_git(repository_path, ["rev-parse", `origin/${branch}`]);
+  if (local === void 0 || remote === void 0) return false;
+  return local === remote;
+}
+function commit_ahead(repository_path, default_name) {
+  const head = run_git(repository_path, ["rev-parse", "HEAD"]);
+  const base = run_git(repository_path, ["rev-parse", default_name]);
+  if (head === void 0 || head === base) return void 0;
+  return run_git(repository_path, ["rev-parse", "--short", "HEAD"]);
+}
+function has_remote_branch(repository_path, branch) {
+  const heads = run_git(repository_path, ls_remote_branch_arguments(branch), REMOTE_TIMEOUT_MS);
+  return heads !== void 0 && heads !== "";
+}
+function hooks_directory(repository_path) {
+  const configured = run_git(repository_path, ["config", "--get", "core.hooksPath"]);
+  if (configured !== void 0 && configured !== "") return configured;
+  return run_git(repository_path, ["rev-parse", "--git-path", "hooks"]);
+}
+function has_pre_push_hook(repository_path) {
+  const directory = hooks_directory(repository_path);
+  if (directory === void 0 || directory === "") return false;
+  return existsSync(path.resolve(repository_path, directory, PRE_PUSH_HOOK));
+}
+function can_push_without_hooks(repository_path, branch) {
+  const args = ["push", "--dry-run", "--no-verify", "origin", branch];
+  return run_git(repository_path, args, REMOTE_TIMEOUT_MS) !== void 0;
+}
+function decide_tree_state(branch, default_name, is_tree_clean, is_current) {
+  if (!is_tree_clean) return { is_ready: false, reason: "working tree has uncommitted changes" };
+  if (branch !== default_name) {
+    return { is_ready: false, reason: `on branch ${branch}, not ${default_name}` };
+  }
+  return is_current ? { is_ready: true } : { is_ready: false, reason: `${branch} is not up to date` };
+}
+function tree_state(repository_path) {
+  const branch = current_branch(repository_path);
+  if (branch === void 0) return { is_ready: false, reason: "not a readable git repository" };
+  const default_name = default_branch(repository_path);
+  return decide_tree_state(
+    branch,
+    default_name,
+    is_clean(repository_path),
+    is_up_to_date(repository_path, branch)
+  );
+}
+function return_to_default_branch(repository_path) {
+  const branch = default_branch(repository_path);
+  if (run_git(repository_path, ["checkout", branch]) === void 0) return false;
+  return run_git(repository_path, ["pull", "--ff-only", "origin", branch]) !== void 0;
+}
+var propagate_git = {
+  default_branch,
+  return_to_default_branch,
+  current_branch,
+  commit_ahead,
+  has_remote_branch,
+  has_pre_push_hook,
+  can_push_without_hooks,
+  is_clean,
+  decide_tree_state,
+  tree_state
+};
+
+// scripts/propagate/propagate-run.ts
+var STEP_PRECHECK = "working tree check";
+var STEP_UPGRADE = "josh vu";
+var STEP_SYNC = "josh sync";
+var STEP_LATEST = "josh latest";
+var STEP_LINT_RELATED = "related lint check";
+var STEP_TEST_RELATED = "related test check";
+var STEP_VERIFY = "verification gate";
+var STEP_ISSUE = "open issue";
+var STEP_PR = "josh git";
+var STEP_RETURN = "return to default branch";
+var STEP_ORDER = [
+  STEP_PRECHECK,
+  STEP_UPGRADE,
+  STEP_SYNC,
+  STEP_LINT_RELATED,
+  STEP_TEST_RELATED,
+  STEP_VERIFY,
+  STEP_ISSUE,
+  STEP_PR,
+  STEP_RETURN
+];
+var ADOPT_STEP_ORDER = STEP_ORDER.flatMap(
+  (step) => step === STEP_SYNC ? [step, STEP_LATEST] : step
+);
+var PROPAGATED_REASON = "opened a pull request";
+var SKIP_REASONS = {
+  up_to_date: "already carries this release",
+  not_downstream: "does not depend on this package",
+  missing_checkout: "no local checkout at the mapped path \u2014 reported, not cloned",
+  unreadable: "package.json could not be read",
+  not_selected: "not the repository --target named",
+  carried_above: "delivered by the propagation of a toolkit above this one"
+};
+function skip_reason(target) {
+  const reason = SKIP_REASONS[target.state] ?? "not eligible";
+  if (target.carriers === void 0) return reason;
+  return `${reason}: ${target.carriers.join(", ")}`;
+}
+var LEFTOVER_NOTE = "upgrade/sync changes left uncommitted";
+function has_leftover_changes(steps) {
+  return steps.some((result) => result.step === STEP_UPGRADE);
+}
+function leftover_of(result, steps) {
+  if (!has_leftover_changes(steps)) return void 0;
+  return result.leftover ?? LEFTOVER_NOTE;
+}
+function failure_reason(result, steps) {
+  const base = result.detail === void 0 ? `${result.step} failed` : `${result.step} failed: ${result.detail}`;
+  const leftover = leftover_of(result, steps);
+  return leftover === void 0 ? base : `${base} \u2014 ${leftover}`;
+}
+function terminal_result(repo, result, steps) {
+  if (!result.is_ok) {
+    return { repo, outcome: "failed", reason: failure_reason(result, steps), steps };
+  }
+  if (result.is_complete === true) {
+    return { repo, outcome: "skipped", reason: result.detail ?? "nothing to do", steps };
+  }
+  return void 0;
+}
+function run_target(target, run_step, success_reason = PROPAGATED_REASON, order = STEP_ORDER) {
+  const steps = [];
+  for (const step of order) {
+    const result = run_step(target, step);
+    steps.push(result);
+    const terminal = terminal_result(target.repo, result, steps);
+    if (terminal !== void 0) return terminal;
+  }
+  return { repo: target.repo, outcome: "propagated", reason: success_reason, steps };
+}
+function run_targets(targets, run_step, success_reason = PROPAGATED_REASON) {
+  return targets.map(
+    (target) => target.state === "ready" ? run_target(target, run_step, success_reason) : { repo: target.repo, outcome: "skipped", reason: skip_reason(target), steps: [] }
+  );
+}
+function has_failure(results) {
+  return results.some((result) => result.outcome === "failed");
+}
+var OUTCOME_ICONS = {
+  propagated: "\u2713",
+  failed: status_icons.FAIL_ICON,
+  skipped: "\u2013"
+};
+function format_result(result) {
+  return `  ${OUTCOME_ICONS[result.outcome]} ${result.repo}  ${result.reason}`;
+}
+function format_report(results) {
+  if (results.length === 0) return "No repositories were considered.";
+  return results.map((result) => format_result(result)).join("\n");
+}
+var propagate_run = {
+  PROPAGATED_REASON,
+  LEFTOVER_NOTE,
+  STEP_RETURN,
+  STEP_PRECHECK,
+  STEP_ISSUE,
+  STEP_UPGRADE,
+  STEP_SYNC,
+  STEP_LATEST,
+  STEP_LINT_RELATED,
+  STEP_TEST_RELATED,
+  STEP_VERIFY,
+  STEP_PR,
+  STEP_ORDER,
+  ADOPT_STEP_ORDER,
+  skip_reason,
+  run_target,
+  run_targets,
+  has_failure,
+  format_report
+};
+
+// scripts/propagate/propagate-steps.ts
+import { execaSync } from "execa";
+
+// scripts/propagate/propagate-git-failure.ts
+var TAIL_LINE_COUNT = 3;
+var TAIL_SEPARATOR = " / ";
+var ANSI_PATTERN = /\[[0-9;?]*[ -/]*[@-~]/gu;
+var LINE_BREAK_PATTERN = /[\r\n]/u;
+var TAIL_LABEL = "last output: ";
+var NO_COMMIT = "nothing was committed";
+var NOT_OPENED = "the branch reached origin, but the pull request was not opened";
+var HOOK_REFUSED = "but the consumer's pre-push hook refused the push";
+var PUSH_FAILED = "but the push did not reach origin";
+var NOTHING_LEFT = "nothing was left behind";
+var LEFTOVER_LABEL = "left behind: ";
+var LEFTOVER_JOIN = " and ";
+var UNCOMMITTED = "uncommitted changes";
+var NOT_PUSHED = { is_on_remote: false, is_push_hook_blocked: false };
+function push_reason(state) {
+  return state.is_push_hook_blocked ? HOOK_REFUSED : PUSH_FAILED;
+}
+function describe_failure(state) {
+  const { branch, head_commit } = state;
+  if (branch === void 0 || head_commit === void 0) return NO_COMMIT;
+  if (state.is_on_remote) return NOT_OPENED;
+  return `committed ${head_commit} on ${branch}, ${push_reason(state)}`;
+}
+function stream_tail(text) {
+  return text.replaceAll(ANSI_PATTERN, "").split(LINE_BREAK_PATTERN).map((line) => line.trim()).filter((line) => line !== "").slice(-TAIL_LINE_COUNT).join(TAIL_SEPARATOR);
+}
+function output_tail(streams) {
+  const tails = streams.map((text) => stream_tail(text)).filter((tail) => tail !== "");
+  if (tails.length === 0) return "";
+  return ` \u2014 ${TAIL_LABEL}${tails.join(TAIL_SEPARATOR)}`;
+}
+function leftover_note(state) {
+  const parts = [];
+  if (!state.is_tree_clean) parts.push(UNCOMMITTED);
+  if (state.branch !== void 0) parts.push(`the branch ${state.branch}`);
+  if (parts.length === 0) return NOTHING_LEFT;
+  return `${LEFTOVER_LABEL}${parts.join(LEFTOVER_JOIN)}`;
+}
+function feature_branch(repository_path, default_name) {
+  const branch = propagate_git.current_branch(repository_path);
+  return branch === void 0 || branch === default_name ? void 0 : branch;
+}
+function read_push_state(repository_path, branch, head_commit) {
+  if (branch === void 0 || head_commit === void 0) return NOT_PUSHED;
+  if (propagate_git.has_remote_branch(repository_path, branch)) {
+    return { is_on_remote: true, is_push_hook_blocked: false };
+  }
+  return {
+    is_on_remote: false,
+    is_push_hook_blocked: propagate_git.has_pre_push_hook(repository_path) && propagate_git.can_push_without_hooks(repository_path, branch)
+  };
+}
+function read_state(repository_path) {
+  const default_name = propagate_git.default_branch(repository_path);
+  const branch = feature_branch(repository_path, default_name);
+  const head_commit = branch === void 0 ? void 0 : propagate_git.commit_ahead(repository_path, default_name);
+  return {
+    branch,
+    head_commit,
+    is_tree_clean: propagate_git.is_clean(repository_path),
+    ...read_push_state(repository_path, branch, head_commit)
+  };
+}
+function attribute(repository_path, result, streams) {
+  const state = read_state(repository_path);
+  const detail = `${result.detail ?? "failed"} \u2014 ${describe_failure(state)}${output_tail(streams)}`;
+  return { ...result, detail, leftover: leftover_note(state) };
+}
+var propagate_git_failure = {
+  HOOK_REFUSED,
+  NOTHING_LEFT,
+  NO_COMMIT,
+  NOT_OPENED,
+  PUSH_FAILED,
+  UNCOMMITTED,
+  attribute,
+  describe_failure,
+  leftover_note,
+  output_tail,
+  read_state
+};
+
+// scripts/propagate/propagate-steps.ts
+var SUCCESS_EXIT_CODE = 0;
+var VERIFY_SCRIPT = `pnpm josh ${GATE_COMMAND}`;
+var LATEST_SCRIPT = "pnpm install --no-frozen-lockfile && pnpm josh latest";
+var STEP_COMMANDS = {
+  [propagate_run.STEP_LATEST]: ["sh", "-c", LATEST_SCRIPT],
+  [propagate_run.STEP_LINT_RELATED]: ["pnpm", "josh", "lint:related"],
+  [propagate_run.STEP_TEST_RELATED]: ["pnpm", "josh", "test:related"],
+  [propagate_run.STEP_VERIFY]: ["sh", "-c", VERIFY_SCRIPT]
+};
+var JOSH_BIN = "josh";
+function sync_command(bin_name) {
+  return ["pnpm", bin_name, "sync"];
+}
+function upgrade_command(package_name, version, root = process.cwd()) {
+  const config = create_version_command_config({ package_name });
+  return build_upgrade_command(version, true, config, root).steps;
+}
+var PROPAGATE_ORIGIN = "Opened by `josh propagate` from the supplier repository after the release was published.";
+var RUN_NOTE = "The upgrade, the managed-file sync and the verification gate have already run here.";
+var UPGRADE_CLASSIFICATION = OTHER_CHANGE_LABEL;
+var EMPTY_PLAN_TITLE = "Upgrade the installed toolkits";
+var LAST_SEPARATOR = " and ";
+var NAME_SEPARATOR = ", ";
+function issue_title(package_name, version) {
+  return `Upgrade ${package_name} to ${version}`;
+}
+function release_names(releases) {
+  const names = releases.map((release) => release.package_name);
+  const last = names.at(-1) ?? "";
+  if (names.length <= 1) return last;
+  return `${names.slice(0, -1).join(NAME_SEPARATOR)}${LAST_SEPARATOR}${last}`;
+}
+function versioned_names(releases) {
+  const named = releases.map((release) => ({
+    ...release,
+    package_name: `${release.package_name} to ${release.version}`
+  }));
+  return `Upgrade ${release_names(named)}`;
+}
+function plan_title(releases) {
+  const [first] = releases;
+  if (first === void 0) return EMPTY_PLAN_TITLE;
+  const is_one_version = releases.every((release) => release.version === first.version);
+  return is_one_version ? issue_title(release_names(releases), first.version) : versioned_names(releases);
+}
+function plan_body(plan) {
+  const specs = plan.releases.map((release) => `\`${release.package_name}@${release.version}\``).join(NAME_SEPARATOR);
+  return [
+    `Carry ${specs} into this repository.`,
+    "",
+    plan.origin,
+    RUN_NOTE,
+    "",
+    pr_classification.declaration(UPGRADE_CLASSIFICATION)
+  ].join("\n");
+}
+function issue_body(package_name, version) {
+  return plan_body({
+    releases: [{ package_name, version, bin_name: JOSH_BIN }],
+    origin: PROPAGATE_ORIGIN
+  });
+}
+var NO_COMMAND = "no command defined";
+function captured(text = "") {
+  return text;
+}
+function step_result(step, exit_code) {
+  if (exit_code === SUCCESS_EXIT_CODE) return { step, is_ok: true };
+  return { step, is_ok: false, detail: `exit ${String(exit_code ?? "timed out")}` };
+}
+function spawn_step(target, step, command) {
+  const [executable, ...rest] = command;
+  if (executable === void 0) return { step, is_ok: false, detail: NO_COMMAND };
+  const spawned = execaSync(executable, rest, {
+    cwd: target.path,
+    reject: false,
+    stdio: "inherit",
+    timeout: SUITE_TIMEOUT_MS
+  });
+  return step_result(step, spawned.exitCode);
+}
+function spawn_captured(target, step, command) {
+  const [executable, ...rest] = command;
+  if (executable === void 0) {
+    return { result: { step, is_ok: false, detail: NO_COMMAND }, streams: [] };
+  }
+  const spawned = execaSync(executable, rest, {
+    cwd: target.path,
+    reject: false,
+    stdin: "inherit",
+    stdout: ["inherit", "pipe"],
+    stderr: ["inherit", "pipe"],
+    timeout: SUITE_TIMEOUT_MS
+  });
+  return {
+    result: step_result(step, spawned.exitCode),
+    streams: [captured(spawned.stdout), captured(spawned.stderr)]
+  };
+}
+function precheck_step(target, step) {
+  const state = propagate_git.tree_state(target.path);
+  if (state.is_ready) return { step, is_ok: true };
+  return { step, is_ok: false, detail: state.reason ?? "not ready" };
+}
+function to_issue_detail(error) {
+  const message = error_text.message_of(error);
+  return message.replaceAll("\n", " ").trim();
+}
+function create_issue(target, title, body) {
+  try {
+    const url = git_gh_exec.exec_gh_api_sync(
+      git_gh_issue_write.issue_create_request({ title, body, repo: target.repo })
+    );
+    return { url };
+  } catch (error) {
+    return { detail: to_issue_detail(error) };
+  }
+}
+function open_issue(target, package_name, version) {
+  return create_issue(target, issue_title(package_name, version), issue_body(package_name, version));
+}
+var ISSUE_NUMBER_PATTERN = /\/(?<number>\d+)\s*$/u;
+function parse_issue_number(issue_url) {
+  const { groups } = ISSUE_NUMBER_PATTERN.exec(issue_url.trim()) ?? {};
+  const { number: issue_number } = groups ?? {};
+  return issue_number;
+}
+function issue_step(target, step, plan, issue_numbers) {
+  if (propagate_git.is_clean(target.path)) {
+    return { step, is_ok: true, is_complete: true, detail: "already current \u2014 nothing to commit" };
+  }
+  const outcome = create_issue(target, plan_title(plan.releases), plan_body(plan));
+  const number = parse_issue_number(outcome.url ?? "");
+  if (number === void 0) {
+    return { step, is_ok: false, detail: outcome.detail ?? "could not open an issue" };
+  }
+  issue_numbers.set(target.repo, number);
+  return { step, is_ok: true };
+}
+function return_step(target, step) {
+  if (propagate_git.return_to_default_branch(target.path)) return { step, is_ok: true };
+  return { step, is_ok: false, detail: "left on the pull request branch" };
+}
+function pull_request_step(target, step, plan, issue_numbers) {
+  const number = issue_numbers.get(target.repo);
+  if (number === void 0) return { step, is_ok: false, detail: "no issue number" };
+  const argument = `${plan_title(plan.releases)} ${issue_cite.plain_for("github", number)}`;
+  const outcome = spawn_captured(target, step, ["pnpm", "josh", "git", "-y", argument]);
+  if (outcome.result.is_ok) return outcome.result;
+  return propagate_git_failure.attribute(target.path, outcome.result, outcome.streams);
+}
+function run_each(target, step, commands) {
+  for (const { package_name, command } of commands) {
+    const result = spawn_step(target, step, command);
+    if (!result.is_ok) return { ...result, detail: `${package_name}: ${result.detail ?? "failed"}` };
+  }
+  return { step, is_ok: true };
+}
+function upgrade_commands(plan, root = process.cwd()) {
+  return plan.releases.flatMap(
+    (release) => upgrade_command(release.package_name, release.version, root).map((command) => ({
+      package_name: release.package_name,
+      command
+    }))
+  );
+}
+function sync_commands(plan) {
+  return plan.releases.map((release) => ({
+    package_name: release.package_name,
+    command: sync_command(release.bin_name)
+  }));
+}
+function create_step_runner(plan) {
+  const issue_numbers = /* @__PURE__ */ new Map();
+  const handlers = {
+    [propagate_run.STEP_PRECHECK]: precheck_step,
+    [propagate_run.STEP_UPGRADE]: (target, step) => run_each(target, step, upgrade_commands(plan, target.path)),
+    [propagate_run.STEP_SYNC]: (target, step) => run_each(target, step, sync_commands(plan)),
+    [propagate_run.STEP_ISSUE]: (target, step) => issue_step(target, step, plan, issue_numbers),
+    [propagate_run.STEP_PR]: (target, step) => pull_request_step(target, step, plan, issue_numbers),
+    [propagate_run.STEP_RETURN]: return_step
+  };
+  return (target, step) => {
+    console.info(`  ${target.repo}: ${step}`);
+    const handler = handlers[step];
+    if (handler !== void 0) return handler(target, step);
+    return spawn_step(target, step, STEP_COMMANDS[step] ?? []);
+  };
+}
+function describe_step(target, step) {
+  console.info(`  ${target.repo}: would run ${step}`);
+  return { step, is_ok: true };
+}
+var propagate_steps = {
+  JOSH_BIN,
+  PROPAGATE_ORIGIN,
+  sync_command,
+  upgrade_command,
+  upgrade_commands,
+  sync_commands,
+  VERIFY_SCRIPT,
+  issue_title,
+  issue_body,
+  plan_title,
+  plan_body,
+  parse_issue_number,
+  open_issue,
+  precheck_step,
+  create_step_runner,
+  describe_step
+};
+
+export {
+  propagate_git,
+  propagate_run,
+  propagate_steps
+};

package/dist/commands/chunk-7T7GIZYW.js

@@ -0,0 +1,92 @@
+import {
+  review_readers_scan
+} from "./chunk-W6MVQEMO.js";
+import {
+  git_grep_hits
+} from "./chunk-EWBEYTVS.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/review/review-untouched-readers.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+var SOURCE_FILE = /\.(?:ts|js)$/u;
+var SEARCH_PATHS = ["*.ts", "*.js", "*.svelte", ":(exclude)*.snap"];
+var WORD_FLAG = "-w";
+var MAX_HITS = 10;
+var MAX_NAMES = 30;
+var HEADING = "## Readers outside the diff";
+var ROLE_LINE = "Each exported name this change edits, with every line outside the changed paths that names it (`git grep -w`). Check each reader still holds under the new meaning \u2014 the self-check's \"Every caller moved with it\" (`prompts/review.md`). A reader left on the old meaning is a finding at the reader's `file:line`. A reader reaching the name through an alias or a re-derivation is not listed.";
+var SEARCH_FAILED = "  - git grep failed; not searched";
+var READ_FAILED = "The readers outside the diff could not be read; search them yourself:";
+var OMITTED_TAIL = "not searched; search their readers yourself";
+var NO_READ = { readers: [], omitted: 0, has_failed: false };
+var FAILED_READ = { readers: [], omitted: 0, has_failed: true };
+async function file_edits(request, relative) {
+  const { root, base } = request;
+  const diff = await git_spawn.read(["-C", root, "diff", "-U0", "--no-color", base, "--", relative]);
+  if (diff.length === 0) return { relative, edits: [] };
+  try {
+    const source = readFileSync(path.join(root, relative), "utf8");
+    return { relative, edits: review_readers_scan.edited(source, diff) };
+  } catch {
+    return { relative, edits: [] };
+  }
+}
+function excluded(paths) {
+  return paths.map((relative) => `:(exclude,literal)${relative}`);
+}
+async function readers_of(request, entry, edit) {
+  const pathspecs = [...SEARCH_PATHS, ...excluded(request.paths)];
+  const found = await git_grep_hits.search(edit.target, [WORD_FLAG], pathspecs, request.root);
+  return { target: edit.target, origin: `${entry.relative}:${String(edit.line)}`, ...found };
+}
+async function read(request) {
+  const sources = request.paths.filter((relative) => SOURCE_FILE.test(relative));
+  const files = await Promise.all(
+    sources.map(async (relative) => await file_edits(request, relative))
+  );
+  const pairs = files.flatMap((entry) => entry.edits.map((edit) => ({ entry, edit })));
+  const capped = pairs.slice(0, MAX_NAMES);
+  const all = await Promise.all(
+    capped.map(async ({ entry, edit }) => await readers_of(request, entry, edit))
+  );
+  const readers = all.filter((entry) => entry.has_failed || entry.hits.length > 0);
+  return { readers, omitted: pairs.length - capped.length, has_failed: false };
+}
+function hit_line(hit) {
+  return `  - ${hit.path}:${hit.line}  ${hit.excerpt}`;
+}
+function readers_lines(readers) {
+  const head = `- \`${readers.target}\` \u2014 ${readers.origin}`;
+  if (readers.has_failed) return [head, SEARCH_FAILED];
+  const more = readers.hits.length - MAX_HITS;
+  const tail = more > 0 ? [`  - \u2026 and ${String(more)} more`] : [];
+  return [head, ...readers.hits.slice(0, MAX_HITS).map((hit) => hit_line(hit)), ...tail];
+}
+function omitted_lines(omitted) {
+  if (omitted === 0) return [];
+  return [`- \u2026 and ${String(omitted)} more edited names ${OMITTED_TAIL}`];
+}
+function brief_block(read_result = NO_READ) {
+  const { readers, omitted, has_failed } = read_result;
+  if (has_failed) return ["", `${HEADING}
+${READ_FAILED}`];
+  if (omitted === 0 && readers.length === 0) return [];
+  const listed = readers.flatMap((entry) => readers_lines(entry));
+  return ["", [HEADING, ROLE_LINE, ...listed, ...omitted_lines(omitted)].join("\n")];
+}
+var review_untouched_readers = {
+  brief_block,
+  FAILED_READ,
+  HEADING,
+  MAX_NAMES,
+  OMITTED_TAIL,
+  read,
+  READ_FAILED
+};
+
+export {
+  review_untouched_readers
+};