@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-MK4CARBI.js

@@ -0,0 +1,90 @@
+import {
+  lane_plan_signals
+} from "./chunk-4GUGC4IW.js";
+import {
+  lane_ledger_archive
+} from "./chunk-ESUY7KTZ.js";
+import {
+  lane_stage_stats
+} from "./chunk-J4XHEOOW.js";
+import {
+  lane_stats
+} from "./chunk-2XLR7R6E.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-plan-wait.ts
+var WAIT_CAP_MINUTES = 30;
+var WAIT_CAP_MS = WAIT_CAP_MINUTES * MS_PER_MINUTE;
+var MEDIAN_PERIOD_DAYS = 3;
+var ASK_MINUTES = 9;
+var ASK_MS = ASK_MINUTES * MS_PER_MINUTE;
+function deadline_of(facts) {
+  const { own_at_ms, holder_at_ms, now_ms } = facts;
+  if (!facts.has_commits || own_at_ms >= holder_at_ms) return void 0;
+  const remaining = facts.median_ms - (now_ms - holder_at_ms);
+  const bound = Math.min(now_ms - own_at_ms, WAIT_CAP_MS);
+  return remaining <= bound ? now_ms + bound : void 0;
+}
+function dispatched_at(entries, issue) {
+  const starts = entries.filter((entry) => lane_stage_stats.is_dispatch(entry) && entry.issue === issue).map((entry) => Date.parse(entry.at));
+  return lane_stats.peak(starts);
+}
+function median_ms(entries, now_ms) {
+  const period = lane_stats.in_window(entries, lane_stats.window_of(MEDIAN_PERIOD_DAYS, now_ms));
+  const minutes = lane_stats.median(lane_stats.merge_minutes(entries, period));
+  return minutes === void 0 ? void 0 : minutes * MS_PER_MINUTE;
+}
+function facts_from(entries, pair, has_commits, now_ms) {
+  const own_at_ms = dispatched_at(entries, pair.issue);
+  const holder_at_ms = dispatched_at(entries, pair.holder);
+  const median = median_ms(entries, now_ms);
+  if (own_at_ms === void 0 || holder_at_ms === void 0 || median === void 0) {
+    return void 0;
+  }
+  return { own_at_ms, holder_at_ms, has_commits, median_ms: median, now_ms };
+}
+async function entries_of() {
+  const ledger = await lane_ledger.target();
+  return ledger === void 0 ? [] : lane_ledger_archive.history_at(ledger);
+}
+async function deadline(issue, holder, now_ms) {
+  const [entries, signals] = await Promise.all([entries_of(), lane_plan_signals.signals_of(issue)]);
+  const facts = facts_from(entries, { issue, holder }, signals.committed_files.length > 0, now_ms);
+  return facts === void 0 ? void 0 : deadline_of(facts);
+}
+async function hold(until_ms, is_free, sleeper = poll.sleep) {
+  const ask_end_ms = Date.now() + ASK_MS;
+  return await poll.wait_for(
+    async () => {
+      if (Date.now() >= until_ms) return "expired";
+      if (await is_free()) return "free";
+      return Date.now() + MS_PER_MINUTE > ask_end_ms ? "again" : void 0;
+    },
+    { interval_ms: MS_PER_MINUTE, sleeper }
+  );
+}
+var lane_plan_wait = { deadline, deadline_of, facts_from, hold };
+
+// scripts/lane/lane-plan-wait-until.ts
+async function until(plan, holder) {
+  const now_ms = Date.now();
+  if (plan.waits_until !== void 0) {
+    return Date.parse(plan.waits_until) > now_ms ? plan.waits_until : void 0;
+  }
+  const deadline2 = await lane_plan_wait.deadline(plan.issue, holder, now_ms);
+  return deadline2 === void 0 ? void 0 : new Date(deadline2).toISOString();
+}
+var lane_plan_wait_until = { until };
+
+export {
+  lane_plan_wait,
+  lane_plan_wait_until
+};

package/dist/commands/chunk-MLJDW7YN.js

@@ -0,0 +1,64 @@
+import {
+  git_gh_exec
+} from "./chunk-43DU7DYZ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/repo/repo-setting.ts
+var GH_TIMEOUT_MS = 5e3;
+var REPO_PLACEHOLDER = "<owner>/<repo>";
+var UNKNOWN_REPOSITORY = "unknown repository";
+var FAILED_EXIT_CODE = 1;
+function query_repo_api(api_path) {
+  const stdout = git_gh_exec.read_gh_api_sync({
+    path: api_path,
+    cwd: PROJECT_ROOT,
+    timeout_ms: GH_TIMEOUT_MS
+  });
+  return stdout === void 0 ? { exit_code: FAILED_EXIT_CODE, stdout: "" } : { exit_code: 0, stdout };
+}
+function parse_payload(exit_code, stdout) {
+  if (exit_code !== 0) return void 0;
+  const parsed = json_value.parse_or_undefined(stdout);
+  return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+}
+function read_field(payload, field) {
+  return payload === void 0 ? void 0 : Reflect.get(payload, field);
+}
+function classify_boolean_setting(payload, field) {
+  const value = read_field(payload, field);
+  if (typeof value !== "boolean") return "unreadable";
+  return value ? "enabled" : "disabled";
+}
+function command_target(repo) {
+  return repo ?? REPO_PLACEHOLDER;
+}
+function report_target(repo) {
+  return repo ?? UNKNOWN_REPOSITORY;
+}
+function print_section(lines) {
+  console.info("");
+  for (const line of lines) {
+    console.info(line);
+  }
+}
+var repo_setting = {
+  GH_TIMEOUT_MS,
+  REPO_PLACEHOLDER,
+  UNKNOWN_REPOSITORY,
+  query_repo_api,
+  parse_payload,
+  read_field,
+  classify_boolean_setting,
+  command_target,
+  report_target,
+  print_section
+};
+
+export {
+  repo_setting
+};

package/dist/commands/chunk-MNLHYAJO.js

@@ -0,0 +1,80 @@
+import {
+  direct_importers
+} from "./chunk-N4EMFHQ6.js";
+
+// scripts/test/related-heavy-tests.ts
+import path2 from "node:path";
+
+// scripts/test/unit-durations.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+var RECORD_FILE = "tools/test/unit-durations.json";
+function parse(text) {
+  const parsed = JSON.parse(text);
+  if (typeof parsed !== "object" || parsed === null) return {};
+  return Object.fromEntries(
+    Object.entries(parsed).filter(
+      (entry) => typeof entry[1] === "number"
+    )
+  );
+}
+function read(root) {
+  try {
+    return parse(readFileSync(path.join(root, RECORD_FILE), "utf8"));
+  } catch {
+    return {};
+  }
+}
+var unit_durations = {
+  RECORD_FILE,
+  parse,
+  read
+};
+
+// scripts/test/vitest-cli-excludes.ts
+var EXCLUDE_FLAG = "--exclude";
+function cli_excludes(argv) {
+  return argv.slice(1).filter((_argument, index) => argv[index] === EXCLUDE_FLAG);
+}
+var vitest_cli_excludes = { EXCLUDE_FLAG, cli_excludes };
+
+// scripts/test/related-heavy-tests.ts
+var HEAVY_TEST_MS = 1e4;
+var { EXCLUDE_FLAG: EXCLUDE_FLAG2 } = vitest_cli_excludes;
+var TEST_SUFFIX_PATTERN = /(?:\.integration)?\.test$/u;
+var { module_key } = direct_importers;
+function heavy_tests(durations) {
+  return Object.keys(durations).filter((file) => (durations[file] ?? 0) > HEAVY_TEST_MS);
+}
+function imports_directly(file, scoped, reader) {
+  const source = reader.read_source(file);
+  if (source === void 0) return true;
+  return direct_importers.names_any(source, file, scoped, reader.imports);
+}
+function is_kept(file, scoped, reader) {
+  const key = module_key(file);
+  if (scoped.has(key) || scoped.has(key.replace(TEST_SUFFIX_PATTERN, ""))) return true;
+  return imports_directly(file, scoped, reader);
+}
+function excluded_tests(scoped_files, reader) {
+  const scoped = new Set(scoped_files.map((file) => module_key(file)));
+  return heavy_tests(reader.durations).filter((file) => !is_kept(file, scoped, reader));
+}
+function file_reader(root) {
+  return { ...direct_importers.source_reader(root), durations: unit_durations.read(root) };
+}
+function exclude_flags(scope, root, reader = file_reader(root)) {
+  if (scope.mode !== "related") return [];
+  const scoped = scope.files.map((file) => path2.relative(root, file));
+  return excluded_tests(scoped, reader).flatMap((file) => [EXCLUDE_FLAG2, file]);
+}
+var related_heavy_tests = {
+  EXCLUDE_FLAG: EXCLUDE_FLAG2,
+  HEAVY_TEST_MS,
+  exclude_flags,
+  heavy_tests
+};
+
+export {
+  related_heavy_tests
+};

package/dist/commands/chunk-MOD3FG4V.js

@@ -0,0 +1,419 @@
+import {
+  epic_decision,
+  epic_sections
+} from "./chunk-XSKB6ZUA.js";
+import {
+  epic_validate
+} from "./chunk-RFWB2KAV.js";
+import {
+  epic_fetch
+} from "./chunk-BML6MEUB.js";
+import {
+  UNORDERED_DEPENDENCIES,
+  chain_links,
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  DEPENDENCY_ARROW,
+  format_dependency_link,
+  format_issue_references,
+  to_issue_reference
+} from "./chunk-2ADQ5XRD.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  EPIC_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/epic/epic-read.ts
+var UNKNOWN_REPO = "Could not read this repository from `git remote`, so the epic's relations cannot be keyed by repository \u2014 check `gh auth status` and that this is a checkout with an `origin` remote.";
+async function read_subject(epic_number) {
+  return epic_validate.parse_epic_subject(
+    await git_gh_command.issue_get_labels_and_body(String(epic_number))
+  );
+}
+async function read_recorded(body) {
+  const repo = await git_gh_command.repo_get_name_with_owner();
+  if (repo === void 0) return { error: UNKNOWN_REPO };
+  const tracked = epic_parse.parse_task_list_issue_numbers(body);
+  if (tracked.length === 0) return { children: [], repo };
+  const fetched = await epic_fetch.fetch_children(tracked, repo);
+  if (fetched.unreadable.length > 0) {
+    const list = epic_graph.format_references(fetched.unreadable, repo);
+    return { error: `Could not read ${list}; the epic's dependency graph is incomplete.` };
+  }
+  return { children: fetched.children, repo };
+}
+async function read_epic(epic_number) {
+  const subject = await read_subject(epic_number);
+  const unread = `Could not read issue ${session_cite.issue(epic_number)}.`;
+  if (subject === void 0) return { error: unread };
+  const recorded = await read_recorded(subject.body);
+  if ("error" in recorded) return { error: recorded.error };
+  return { subject, recorded: recorded.children, repo: recorded.repo };
+}
+var epic_read = {
+  read_subject,
+  read_epic
+};
+
+// scripts/epic/epic-chains.ts
+var AMBIGUOUS_MATCH_COUNT = 2;
+function render_chains(chains) {
+  return chains.filter((chain) => chain.length > 1).map((chain) => chain.map((number) => to_issue_reference(number)).join(DEPENDENCY_ARROW));
+}
+function links_of(chains) {
+  const links = chains.flatMap((chain) => chain_links(chain));
+  return [...new Map(links.map((link) => [format_dependency_link(link), link])).values()];
+}
+function diff_links(before, after) {
+  const before_links = links_of(before);
+  const after_links = links_of(after);
+  const before_keys = new Set(before_links.map((link) => format_dependency_link(link)));
+  const after_keys = new Set(after_links.map((link) => format_dependency_link(link)));
+  return {
+    added: after_links.filter((link) => !before_keys.has(format_dependency_link(link))),
+    removed: before_links.filter((link) => !after_keys.has(format_dependency_link(link)))
+  };
+}
+function chains_containing(chains, target) {
+  return chains.map((chain, index) => chain.includes(target) ? index : -1).filter((index) => index !== -1);
+}
+function find_repeated_reference(chains) {
+  for (const chain of chains) {
+    const repeated = chain.find((issue_number, index) => chain.indexOf(issue_number) !== index);
+    if (repeated !== void 0) return repeated;
+  }
+  return void 0;
+}
+function chain_for(additions, position) {
+  return position.kind === "before" ? [...additions, position.target] : [position.target, ...additions];
+}
+function start_chain(additions, position) {
+  return { chains: [chain_for(additions, position)] };
+}
+function add_chain(chains, additions, position) {
+  return { chains: [...chains.map((chain) => [...chain]), chain_for(additions, position)] };
+}
+function not_a_child_error(target) {
+  return {
+    error: `${to_issue_reference(target)} is not a child of this epic, so it cannot position an insertion.`
+  };
+}
+function insert_outside_chains(chains, additions, position, tracked) {
+  if (tracked.includes(position.target)) return add_chain(chains, additions, position);
+  return not_a_child_error(position.target);
+}
+function has_successor(chain, target) {
+  return chain.indexOf(target) < chain.length - 1;
+}
+function is_branching_after(chains, indices, position) {
+  if (position.kind !== "after") return false;
+  return indices.every((index) => has_successor(chains[index] ?? [], position.target));
+}
+function is_shared_before(chains, indices, position) {
+  if (position.kind !== "before") return false;
+  const predecessors = indices.map((index) => {
+    const chain = chains[index] ?? [];
+    return chain[chain.indexOf(position.target) - 1];
+  });
+  return predecessors.every((predecessor) => predecessor === predecessors[0]);
+}
+function is_single_place(chains, indices, position) {
+  return indices.length < AMBIGUOUS_MATCH_COUNT || is_shared_before(chains, indices, position);
+}
+function to_ambiguous_position_error(position) {
+  return `${to_issue_reference(position.target)} appears in more than one declared chain, so "${position.kind}" does not identify one place; edit the declaration by hand.`;
+}
+function find_position_ambiguity(chains, position) {
+  if (position?.kind !== "before" || is_single_place(chains, chains_containing(chains, position.target), position)) {
+    return void 0;
+  }
+  return to_ambiguous_position_error(position);
+}
+function splice_chain(chain, additions, position) {
+  const at = chain.indexOf(position.target) + (position.kind === "after" ? 1 : 0);
+  return [...chain.slice(0, at), ...additions, ...chain.slice(at)];
+}
+function splice_into_chains(chains, indices, additions, position) {
+  return {
+    chains: chains.map(
+      (chain, index) => indices.includes(index) ? splice_chain(chain, additions, position) : [...chain]
+    )
+  };
+}
+function insert_at_position(chains, additions, position, tracked) {
+  const indices = chains_containing(chains, position.target);
+  if (indices.length === 0) return insert_outside_chains(chains, additions, position, tracked);
+  if (is_branching_after(chains, indices, position)) return add_chain(chains, additions, position);
+  if (!is_single_place(chains, indices, position)) {
+    return { error: to_ambiguous_position_error(position) };
+  }
+  return splice_into_chains(chains, indices, additions, position);
+}
+function keep_declaration(chains) {
+  return { chains: chains.map((chain) => [...chain]) };
+}
+function start_chain_or_refuse(additions, position, tracked) {
+  if (!tracked.includes(position.target)) return not_a_child_error(position.target);
+  return start_chain(additions, position);
+}
+function apply_insertion(chains, additions, position, tracked) {
+  if (position === void 0) return keep_declaration(chains);
+  if (chains.length === 0) return start_chain_or_refuse(additions, position, tracked);
+  return insert_at_position(chains, additions, position, tracked);
+}
+function find_already_declared_addition(chains, additions) {
+  const declared = new Set(chains.flat());
+  return additions.find((addition) => declared.has(addition));
+}
+function already_declared_error(issue_number) {
+  const reference = to_issue_reference(issue_number);
+  return `${reference} is already named in the declared dependency order; inserting it again would have it block itself.`;
+}
+function find_insertion_error(chains, additions) {
+  const repeated = find_repeated_reference(chains);
+  if (repeated !== void 0) {
+    return `The declared dependency order names ${to_issue_reference(repeated)} twice; fix the declaration before inserting.`;
+  }
+  const declared = find_already_declared_addition(chains, additions);
+  return declared === void 0 ? void 0 : already_declared_error(declared);
+}
+function remove_children(chains, children) {
+  const dropped = new Set(children);
+  return chains.map((chain) => chain.filter((issue_number) => !dropped.has(issue_number))).filter((chain) => chain.length > 1);
+}
+function break_indices(chain, dropped) {
+  return chain.map((blocked, index) => {
+    const blocker = chain[index - 1];
+    return blocker !== void 0 && dropped.has(format_dependency_link({ blocker, blocked })) ? index : -1;
+  }).filter((index) => index !== -1);
+}
+function split_chain(chain, dropped) {
+  const bounds = [0, ...break_indices(chain, dropped), chain.length];
+  return bounds.slice(0, -1).map((start, index) => chain.slice(start, bounds[index + 1]));
+}
+function remove_links(chains, links) {
+  const dropped = new Set(links.map((link) => format_dependency_link(link)));
+  return chains.flatMap((chain) => split_chain(chain, dropped)).filter((chain) => chain.length > 1);
+}
+function insert_children(chains, additions, position, tracked) {
+  const error = find_insertion_error(chains, additions);
+  if (error !== void 0) return { error };
+  const outcome = apply_insertion(chains, additions, position, tracked);
+  if ("error" in outcome) return outcome;
+  const duplicated = find_repeated_reference(outcome.chains);
+  return duplicated === void 0 ? outcome : { error: already_declared_error(duplicated) };
+}
+var epic_chains = {
+  render_chains,
+  links_of,
+  diff_links,
+  find_position_ambiguity,
+  // Exported so `--order-before` / `--order-after` can pass the
+  // declaration through by the same function `--add` without a position uses. An order-only move is
+  // "leave the declaration exactly as it stood" applied to a call that *does* name a position, so a
+  // second copy of the passthrough would be the clone `CLAUDE.md` prohibits.
+  keep_declaration,
+  remove_children,
+  remove_links,
+  insert_children
+};
+
+// scripts/epic/epic-add-body.ts
+var { find_indices, is_in_range, to_body_lines } = epic_sections;
+function to_task_row(issue_number) {
+  return `- [ ] ${to_issue_reference(issue_number)}`;
+}
+function to_task_rows(placed) {
+  return placed.map((issue_number) => to_task_row(issue_number));
+}
+function append_task_rows(input, placed) {
+  const rows = find_indices(input, (line) => epic_parse.is_task_list_line(line));
+  const last = rows.at(-1);
+  if (last === void 0) return [...input.lines];
+  return [
+    ...input.lines.slice(0, last + 1),
+    ...to_task_rows(placed),
+    ...input.lines.slice(last + 1)
+  ];
+}
+function to_row_number(line) {
+  const [issue_number] = epic_parse.parse_task_list_issue_numbers(line);
+  return issue_number;
+}
+function is_placed_row(line, placed) {
+  const issue_number = to_row_number(line);
+  return issue_number !== void 0 && placed.has(issue_number);
+}
+function insert_task_rows(input, placed, position) {
+  const moved = new Set(placed);
+  const dropped = new Set(find_indices(input, (line) => is_placed_row(line, moved)));
+  const kept = input.lines.filter((_line, index) => !dropped.has(index));
+  const [at] = find_indices(to_body_lines(kept), (line) => to_row_number(line) === position.target);
+  if (at === void 0) return [...input.lines];
+  const insert_at = position.kind === "before" ? at : at + 1;
+  return [...kept.slice(0, insert_at), ...to_task_rows(placed), ...kept.slice(insert_at)];
+}
+function to_placed_lines(input) {
+  const lines = to_body_lines(input.body);
+  const { position } = input;
+  if (position === void 0) return append_task_rows(lines, input.placed);
+  return insert_task_rows(lines, input.placed, position);
+}
+var DEPENDENCIES_HEADING = /^#{1,6}[ \t]+Dependencies\b/u;
+function find_dependencies_range(input) {
+  return epic_sections.find_section_range(input, DEPENDENCIES_HEADING);
+}
+function splice_declaration(lines, input) {
+  return lines.flatMap((line, index) => {
+    if (index === input.first) return [...input.rendered];
+    if (input.dropped.has(index)) return [];
+    return [line];
+  });
+}
+function replace_declaration(lines, rendered) {
+  const input = to_body_lines(lines);
+  const range = find_dependencies_range(input);
+  if (range === void 0) return void 0;
+  const found = find_indices(input, (line) => epic_parse.is_declaration_line(line));
+  const declarations = found.filter((index) => is_in_range(index, range));
+  const [first] = declarations;
+  return first === void 0 ? [...lines.slice(0, range.end), ...rendered, ...lines.slice(range.end)] : splice_declaration(lines, { first, dropped: new Set(declarations.slice(1)), rendered });
+}
+function to_safe_declaration(line) {
+  const [rendered] = epic_chains.render_chains(epic_parse.parse_dependency_chains(line));
+  return rendered ?? UNORDERED_DEPENDENCIES;
+}
+function find_stray_declaration(lines) {
+  const input = to_body_lines(lines);
+  const range = find_dependencies_range(input);
+  if (range === void 0) return void 0;
+  const stray = find_indices(input, (line) => epic_parse.is_declaration_line(line)).find(
+    (index) => !is_in_range(index, range)
+  );
+  return stray === void 0 ? void 0 : to_safe_declaration(lines[stray] ?? "");
+}
+function to_written_lines(input) {
+  const with_rows = to_placed_lines(input);
+  const { decision } = input;
+  if (decision === void 0) return with_rows;
+  return epic_decision.append_decision(with_rows.join("\n"), decision).split("\n");
+}
+function is_declaration_unchanged(lines, rendered) {
+  const declared = epic_parse.parse_dependency_chains(lines.join("\n"));
+  return epic_chains.render_chains(declared).join("\n") === rendered.join("\n");
+}
+function to_declared_body(with_rows, rendered) {
+  const stray = find_stray_declaration(with_rows);
+  if (stray !== void 0) {
+    return {
+      error: `The body declares \`${stray}\` outside the \`Dependencies\` section, which no insertion can keep consistent; move it into that section or reword it first.`
+    };
+  }
+  if (is_declaration_unchanged(with_rows, rendered)) return { body: with_rows.join("\n") };
+  const replaced = replace_declaration(with_rows, rendered);
+  return replaced === void 0 ? { error: "Could not locate the `Dependencies` section to rewrite; nothing was written." } : { body: replaced.join("\n") };
+}
+function to_rendered_declaration(input) {
+  const rendered = epic_chains.render_chains(input.chains_after);
+  if (rendered.length > 0) return rendered;
+  return input.does_clear_declaration === true ? [UNORDERED_DEPENDENCIES] : [];
+}
+function build_body(input) {
+  const with_rows = to_written_lines(input);
+  const rendered = to_rendered_declaration(input);
+  if (rendered.length === 0) return { body: with_rows.join("\n") };
+  return to_declared_body(with_rows, rendered);
+}
+function to_link_keys(chains) {
+  return epic_chains.links_of(chains).map((link) => format_dependency_link(link)).toSorted((left, right) => left.localeCompare(right));
+}
+function has_intended_links(body, chains_after) {
+  const written = to_link_keys(epic_parse.parse_dependency_chains(body));
+  const intended = to_link_keys(chains_after);
+  return written.length === intended.length && written.every((key, index) => key === intended[index]);
+}
+function missing_rows(body, expected) {
+  const tracked = epic_parse.parse_task_list_issue_numbers(body);
+  return expected.filter((issue_number) => !tracked.includes(issue_number));
+}
+function to_placement_start(position, target, count) {
+  return position.kind === "before" ? target - count : target + 1;
+}
+function has_intended_rows(body, input) {
+  const { position, placed } = input;
+  if (position === void 0 || placed.length === 0) return true;
+  const tracked = epic_parse.parse_task_list_issue_numbers(body);
+  const target = tracked.indexOf(position.target);
+  if (target === -1) return false;
+  const start = to_placement_start(position, target, placed.length);
+  return placed.every((child, offset) => tracked[start + offset] === child);
+}
+function find_rewrite_error(body, input) {
+  const missing = missing_rows(body, input.placed);
+  if (missing.length > 0) {
+    return `The rewritten body would not track ${format_issue_references(missing)} as a task-list row.`;
+  }
+  if (!epic_parse.has_machine_readable_declaration(body)) {
+    return "The rewritten body would carry no unambiguous machine-readable `Dependencies` declaration.";
+  }
+  if (!has_intended_links(body, input.chains_after)) {
+    return "The rewritten body would declare a different dependency order than the one computed; nothing was written.";
+  }
+  if (!has_intended_rows(body, input)) {
+    return "The rewritten body would not put the placed task-list rows where the position asked; nothing was written.";
+  }
+  return void 0;
+}
+function rewrite_body(input) {
+  const built = build_body(input);
+  if ("error" in built) return built;
+  const error = find_rewrite_error(built.body, input);
+  return error === void 0 ? built : { error };
+}
+var epic_add_body = {
+  rewrite_body
+};
+
+// scripts/epic/epic-shape.ts
+function missing_declaration_error(epic_number) {
+  const check = `josh epic:check ${String(epic_number)}`;
+  return `${to_issue_reference(epic_number)} has no unambiguous machine-readable \`Dependencies\` declaration; run \`${check}\` first.`;
+}
+function promote_remedy(epic_number) {
+  const promote = `josh epic --promote ${String(epic_number)} <N...>`;
+  return `Promote it with \`${promote}\` when it is a request, a discussion or a container; create a new epic over both when it is itself one of the deliverables.`;
+}
+function find_epic_shape_error(subject) {
+  if (has_label_name(subject.labels, EPIC_LABEL)) return void 0;
+  return `${to_issue_reference(subject.epic_number)} does not carry the \`${EPIC_LABEL}\` label, so it is not an epic. ${promote_remedy(subject.epic_number)}`;
+}
+function find_subject_error(subject, tracked) {
+  const reference = to_issue_reference(subject.epic_number);
+  if (subject.body === void 0) return `Could not read the body of ${reference}.`;
+  const shape_error = find_epic_shape_error(subject);
+  if (shape_error !== void 0) return shape_error;
+  if (tracked.length === 0) {
+    return `${reference} tracks no child as a \`- [ ] #N\` row; there is nowhere to add one.`;
+  }
+  return epic_parse.has_machine_readable_declaration(subject.body) ? void 0 : missing_declaration_error(subject.epic_number);
+}
+var epic_shape = {
+  find_subject_error
+};
+
+export {
+  epic_chains,
+  epic_add_body,
+  epic_shape,
+  epic_read
+};