@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-NFRDCRDI.js

@@ -0,0 +1,285 @@
+import {
+  epic_decide,
+  epic_remove
+} from "./chunk-VHSGVCRM.js";
+import {
+  epic_cli,
+  epic_cli_untrack
+} from "./chunk-LE3M42CF.js";
+import {
+  epic_untrack
+} from "./chunk-GL2DZXYD.js";
+import {
+  issue_plan_notify
+} from "./chunk-2ZDVX64H.js";
+import {
+  epic_run
+} from "./chunk-HN3EGYAI.js";
+import {
+  epic_body
+} from "./chunk-LJZERYLG.js";
+import {
+  epic_add,
+  epic_reconcile
+} from "./chunk-XMNPU3J5.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  backlog_overlap
+} from "./chunk-JUQN3OXG.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/epic/epic-notify.ts
+function body_of(notice, slug) {
+  const rows = notice.children.map((child) => `- ${issue_cite.issue_url(slug, String(child))}`);
+  return [...rows, `Next: ${epic_body.format_run_command(notice.epic_number)}`].join("\n");
+}
+async function send(notice) {
+  const slug = await issue_plan_notify.slug_of(void 0);
+  if (slug === void 0) {
+    console.error("\u26A0\uFE0F  epic could not read the repository; no planning notification was sent.");
+    return;
+  }
+  await issue_plan_notify.send_planning({
+    issue_number: String(notice.epic_number),
+    body: body_of(notice, slug),
+    title: notice.title,
+    repo: slug,
+    command: "epic"
+  });
+}
+var SUCCESS_EXIT_CODE = 0;
+function promoted_number(exit_code, epic_number) {
+  return exit_code === SUCCESS_EXIT_CODE ? epic_number : void 0;
+}
+async function announce(request, epic_number) {
+  if (!request.is_notified) return;
+  if (epic_number === void 0) {
+    console.error("\u26A0\uFE0F  epic has no epic number to announce; no planning notification was sent.");
+    return;
+  }
+  await send({ epic_number, children: request.children, title: request.title });
+}
+var epic_notify = { announce, body_of, promoted_number, send };
+
+// scripts/epic/epic-split-reach.ts
+import { existsSync } from "node:fs";
+var SCRIPTS_DIRECTORY = "scripts/";
+var TYPESCRIPT = ".ts";
+var TEST_SUFFIX = ".test.ts";
+var SEPARATOR = "/";
+function is_scripts_module(path) {
+  return path.startsWith(SCRIPTS_DIRECTORY) && path.endsWith(TYPESCRIPT) && !path.endsWith(TEST_SUFFIX);
+}
+function base_name(path) {
+  return path.slice(path.lastIndexOf(SEPARATOR) + 1);
+}
+function names_module(paths, module) {
+  return [...paths].some((path) => base_name(path) === base_name(module));
+}
+function stranded_of(child, declared, is_present) {
+  const own = [...declared.get(child.number) ?? []].filter((path) => is_scripts_module(path));
+  if (own.some((path) => is_present(path))) return [];
+  return own.map((module) => ({
+    child: child.number,
+    module,
+    importers: [...declared].filter(([number, paths]) => number !== child.number && names_module(paths, module)).map(([number]) => number)
+  }));
+}
+function stranded_modules(children, is_present) {
+  const declared = backlog_overlap.declared_of(children);
+  return children.flatMap((child) => stranded_of(child, declared, is_present)).filter((stranded) => stranded.importers.length > 0);
+}
+function format_stranded(stranded) {
+  const importers = stranded.importers.map((number) => session_cite.issue(number)).join(", ");
+  return `  - ${session_cite.issue(stranded.child)} creates \`${stranded.module}\`, named only by ${importers}`;
+}
+function format_refusal(stranded) {
+  return [
+    "\u2716 This split has a child that cannot merge alone \u2014 the new scripts module it creates is imported only from a sibling, and `scripts/build/pack-boundary.test.ts` refuses an unreachable module:",
+    ...stranded.map((entry) => format_stranded(entry)),
+    "Fold the importing child into the creating one as one Issue, or declare the importer in the creating child; nothing was written."
+  ].join("\n");
+}
+async function refusal_of(children) {
+  const bodies = await Promise.all(
+    children.map(async (number) => ({
+      number,
+      body: await git_gh_command.issue_get_body(String(number))
+    }))
+  );
+  const stranded = stranded_modules(bodies, existsSync);
+  return stranded.length === 0 ? void 0 : format_refusal(stranded);
+}
+var epic_split_reach = { format_refusal, refusal_of, stranded_modules };
+
+// scripts/epic/epic.ts
+var FLAGS = "[--ordered] [--rationale-file <path|->] [--origin <owner/repo#N>] [--notify]";
+var USAGE = [
+  `Usage: josh epic "<title>" <N1> <N2> ... ${FLAGS}`,
+  `       josh epic --promote <N> <N1> <N2> ... ${FLAGS} [--title <title>]`,
+  "       josh epic --add <E> <N1> <N2> ... [--before <M> | --after <M>] [--decision-file <path|->]",
+  "       josh epic --add <E> <N1> <N2> ... [--order-before <M> | --order-after <M>] [--decision-file <path|->]",
+  "       josh epic --remove <E> <M> <N> ... [--decision-file <path|->]",
+  "       josh epic --untrack <E> <N1> <N2> ...",
+  "       josh epic --reconcile <E>",
+  "       josh epic --decide <E> <N1> <N2> ... --decision-file <path|->"
+].join("\n");
+var FAILURE_EXIT_CODE = 1;
+var SUCCESS_EXIT_CODE2 = 0;
+async function is_split_stranded(children) {
+  const refusal = await epic_split_reach.refusal_of(children);
+  if (refusal !== void 0) console.error(refusal);
+  return refusal !== void 0;
+}
+async function run_promotion(argv) {
+  const parsed = epic_cli.parse_promote_arguments(argv);
+  if (parsed === void 0) {
+    console.error(`\u2716 An issue number and at least one child issue number are required.
+${USAGE}`);
+    return FAILURE_EXIT_CODE;
+  }
+  if (await is_split_stranded(parsed.children)) return FAILURE_EXIT_CODE;
+  const exit_code = await epic_run.promote_epic({
+    epic_number: parsed.epic_number,
+    children: parsed.children,
+    rationale: epic_cli.read_rationale(parsed.rationale_path),
+    is_ordered: parsed.is_ordered,
+    origin: parsed.origin,
+    title: parsed.title
+  });
+  await epic_notify.announce(parsed, epic_notify.promoted_number(exit_code, parsed.epic_number));
+  return exit_code;
+}
+function to_add_input(parsed) {
+  return {
+    epic_number: parsed.epic_number,
+    children: parsed.children,
+    position: parsed.position,
+    is_order_only: parsed.is_order_only,
+    decision: epic_cli.read_decision(parsed.decision_path)
+  };
+}
+async function run_qualified_addition(found) {
+  const local = epic_cli.resolve_local_add(found, await git_gh_command.repo_get_name_with_owner());
+  if (local !== void 0) return await epic_add.add_children(to_add_input(local));
+  console.error(epic_cli.format_cross_repo_refusal(found));
+  return FAILURE_EXIT_CODE;
+}
+async function refuse_addition(argv) {
+  const qualified = epic_cli.find_cross_repo_add_target(argv);
+  if (qualified !== void 0) return await run_qualified_addition(qualified);
+  if (epic_cli.is_decision_path_unusable(argv)) {
+    console.error(
+      `\u2716 \`--decision-file\` needs exactly one readable path (\`-\` reads stdin); nothing was written.
+${USAGE}`
+    );
+    return FAILURE_EXIT_CODE;
+  }
+  console.error(
+    `\u2716 An epic number, at least one child issue number, and at most one valid \`--before\` / \`--after\` target are required.
+${USAGE}`
+  );
+  return FAILURE_EXIT_CODE;
+}
+async function run_addition(argv) {
+  const parsed = epic_cli.parse_add_arguments(argv);
+  if (parsed === void 0) return await refuse_addition(argv);
+  return await epic_add.add_children(to_add_input(parsed));
+}
+async function run_removal(argv) {
+  const parsed = epic_cli.parse_remove_arguments(argv);
+  if (parsed === void 0) {
+    console.error(
+      `\u2716 An epic number and at least two child issue numbers are required, and \`--decision-file\` needs exactly one readable path (\`-\` reads stdin).
+${USAGE}`
+    );
+    return FAILURE_EXIT_CODE;
+  }
+  return await epic_remove.remove_order({
+    epic_number: parsed.epic_number,
+    path: parsed.path,
+    decision: epic_cli.read_decision(parsed.decision_path)
+  });
+}
+async function run_decision(argv) {
+  const parsed = epic_cli.parse_decide_arguments(argv);
+  if (parsed === void 0) {
+    console.error(
+      `\u2716 An epic number, at least one child issue number, and exactly one readable \`--decision-file\` path (\`-\` reads stdin) are required.
+${USAGE}`
+    );
+    return FAILURE_EXIT_CODE;
+  }
+  return await epic_decide.decide({
+    epic_number: parsed.epic_number,
+    children: parsed.children,
+    decision: epic_cli.read_decision(parsed.decision_path) ?? ""
+  });
+}
+async function run_reconciliation(argv) {
+  const parsed = epic_cli.parse_reconcile_arguments(argv);
+  if (parsed === void 0) {
+    console.error(`\u2716 An epic number is required.
+${USAGE}`);
+    return FAILURE_EXIT_CODE;
+  }
+  return await epic_reconcile.reconcile_epic(parsed.epic_number);
+}
+async function create(argv) {
+  const parsed = epic_cli.parse_create_arguments(argv);
+  if (parsed === void 0) {
+    console.error(`\u2716 A title and at least one child issue number are required.
+${USAGE}`);
+    return { kind: "refused" };
+  }
+  if (await is_split_stranded(parsed.children)) return { kind: "refused" };
+  const epic_number = await epic_run.create_epic_number({
+    title: parsed.title,
+    children: parsed.children,
+    rationale: epic_cli.read_rationale(parsed.rationale_path),
+    is_ordered: parsed.is_ordered,
+    origin: parsed.origin
+  });
+  await epic_notify.announce(parsed, epic_number);
+  return { kind: "created", epic: epic_number };
+}
+async function run_creation(argv) {
+  const creation = await create(argv);
+  return creation.kind === "refused" ? FAILURE_EXIT_CODE : SUCCESS_EXIT_CODE2;
+}
+async function run_untrack(argv) {
+  const parsed = epic_cli_untrack.parse_arguments(argv);
+  if (parsed === void 0) {
+    console.error(
+      `\u2716 An epic number and at least one distinct child issue number are required.
+${USAGE}`
+    );
+    return FAILURE_EXIT_CODE;
+  }
+  return await epic_untrack.untrack(parsed.epic_number, parsed.children);
+}
+var FLAGGED_FORMS = [
+  [epic_cli_untrack.is_untrack, run_untrack],
+  [epic_cli.is_reconciliation, run_reconciliation],
+  [epic_cli.is_removal, run_removal],
+  [epic_cli.is_decision_entry, run_decision],
+  [epic_cli.is_addition, run_addition],
+  [epic_cli.is_promotion, run_promotion]
+];
+async function run(argv) {
+  const form = FLAGGED_FORMS.find(([is_form]) => is_form(argv));
+  const run_form = form === void 0 ? run_creation : form[1];
+  return await run_form(argv);
+}
+var epic_command = { run, create };
+
+export {
+  epic_command
+};

package/dist/commands/chunk-NHXMWRBI.js

@@ -0,0 +1,16 @@
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.js";
+
+// scripts/issue/issue-park.ts
+async function apply(issue, label, body) {
+  const is_labelled = await git_gh_issue_write.issue_add_label(issue, label);
+  if (!is_labelled) return { is_labelled, is_commented: false };
+  const is_commented = await git_gh_issue_write.issue_try_comment(issue, body);
+  return { is_labelled, is_commented };
+}
+var issue_park = { apply };
+
+export {
+  issue_park
+};

package/dist/commands/chunk-NMG65AFQ.js

@@ -0,0 +1,20 @@
+import {
+  size_estimate
+} from "./chunk-IAA73DWD.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+
+// scripts/issue/issue-declared-size.ts
+async function read(issue) {
+  const body = await git_gh_command.issue_get_body_classified(issue);
+  if (body.kind !== "read") throw new Error(`issue ${issue} body: ${body.kind}`);
+  if (body.text === void 0) return void 0;
+  const estimate = size_estimate.declared_size(body.text);
+  return estimate === void 0 ? void 0 : { files: estimate.files, lines: estimate.lines };
+}
+var issue_declared_size = { read };
+
+export {
+  issue_declared_size
+};

package/dist/commands/chunk-NQ4D2XZY.js

@@ -0,0 +1,213 @@
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/josh/stamp-record.ts
+var NONE_READ = { kind: "none" };
+var UNREADABLE_READ = { kind: "unreadable" };
+function is_older_than(iso, max_age_ms, now) {
+  const at = Date.parse(iso);
+  if (Number.isNaN(at)) return true;
+  return now.getTime() - at > max_age_ms;
+}
+function classify(raw, spec, now) {
+  if (raw === void 0) return NONE_READ;
+  const record = spec.parse(raw);
+  if (record === void 0) return UNREADABLE_READ;
+  const is_expired2 = is_older_than(spec.timestamp_of(record), spec.max_age_ms, now);
+  return { kind: is_expired2 ? "expired" : "carried", record };
+}
+var stamp_record = { classify, is_older_than };
+
+// scripts/run/hold/run-hold.ts
+import { z } from "zod";
+var HOLD_PREFIX = "josh-run-hold-";
+var UNNUMBERED_ISSUE = "new";
+var HOLD_MAX_AGE_HOURS = 8;
+var MILLISECONDS_PER_HOUR = 36e5;
+var HOLD_MAX_AGE_MS = HOLD_MAX_AGE_HOURS * MILLISECONDS_PER_HOUR;
+var RELEASE_COMMAND = "pnpm josh run:release";
+var FORCE_RELEASE_COMMAND = `${RELEASE_COMMAND} --force`;
+var NOT_IDLE = 'that is not "nothing is running here"';
+var FREE_READ = { kind: "free" };
+var UNREADABLE_READ2 = { kind: "unreadable" };
+function hold_path(git_directory) {
+  return stamp_file.stamp_path(HOLD_PREFIX, git_directory);
+}
+async function worktree_directory() {
+  const directories = await git_command.git_directories();
+  return directories[0];
+}
+async function is_linked_worktree() {
+  const directories = await git_command.git_directories();
+  return directories[0] !== void 0 && directories[0] !== directories[1];
+}
+var run_hold_schema = z.object({
+  issue: z.string(),
+  taken_at: z.string(),
+  pid: z.number(),
+  is_fullrun: z.boolean().optional(),
+  is_halfrun_stop: z.boolean().optional(),
+  prrun_stop_head: z.string().optional(),
+  owner_pid: z.number().optional(),
+  owner_start: z.string().optional(),
+  notified_at: z.string().optional()
+});
+function parse_hold(raw) {
+  return json_value.parse_with(raw, run_hold_schema);
+}
+function is_expired(hold, now) {
+  return stamp_record.is_older_than(hold.taken_at, HOLD_MAX_AGE_MS, now);
+}
+function is_stop_marked(hold) {
+  return hold.is_halfrun_stop === true || hold.prrun_stop_head !== void 0;
+}
+function is_owner_gone(hold) {
+  if (is_stop_marked(hold) || hold.owner_pid === void 0) return false;
+  return process_identity.is_same_process(hold.owner_pid, hold.owner_start) === false;
+}
+function is_stale(hold, now) {
+  return is_expired(hold, now) || is_owner_gone(hold);
+}
+function classify2(raw, now) {
+  if (raw === void 0) return FREE_READ;
+  const hold = parse_hold(raw);
+  if (hold === void 0) return UNREADABLE_READ2;
+  return { kind: is_stale(hold, now) ? "stale" : "held", hold };
+}
+function read_hold(target, now = /* @__PURE__ */ new Date()) {
+  return classify2(stamp_file.read_stamp_text(target), now);
+}
+function session_owner(environment = process.env) {
+  const pid = agent_session_environment.session_pid(environment);
+  if (pid === void 0) return {};
+  return { owner_pid: pid, owner_start: process_identity.read_start(pid) };
+}
+function build_hold(issue, now, is_fullrun) {
+  return { issue, taken_at: now.toISOString(), pid: process.pid, is_fullrun, ...session_owner() };
+}
+function write_hold(target, issue, now = /* @__PURE__ */ new Date()) {
+  const hold = build_hold(issue, now);
+  stamp_file.write_stamp(target, hold);
+  return hold;
+}
+function create_hold(target, issue, now = /* @__PURE__ */ new Date(), is_fullrun) {
+  return stamp_file.create_stamp(target, build_hold(issue, now, is_fullrun));
+}
+var HALFRUN_STOP_FIELDS = { is_halfrun_stop: true };
+function create_stop_hold(target, issue, mark, now = /* @__PURE__ */ new Date()) {
+  return stamp_file.create_stamp(target, { ...build_hold(issue, now), ...mark });
+}
+function create_halfrun_stop_hold(target, issue, now = /* @__PURE__ */ new Date()) {
+  return create_stop_hold(target, issue, HALFRUN_STOP_FIELDS, now);
+}
+async function is_tree_dirty(directory) {
+  try {
+    const status = await git_command.status(directory);
+    return status.trim() !== "";
+  } catch (error) {
+    error_text.trace_swallowed("run_hold.is_tree_dirty", error);
+    return true;
+  }
+}
+function release_hold(target) {
+  stamp_file.remove_stamp(target);
+}
+function describe_holder(hold) {
+  const holder = hold.issue === UNNUMBERED_ISSUE ? "an unnumbered run" : session_cite.issue(hold.issue);
+  return `${holder}, recorded ${hold.taken_at} (pid ${String(hold.owner_pid ?? hold.pid)})`;
+}
+function own_release_command(issue) {
+  return issue === UNNUMBERED_ISSUE ? RELEASE_COMMAND : `${RELEASE_COMMAND} ${issue}`;
+}
+function is_own_hold(hold, claimant) {
+  return hold.issue === claimant;
+}
+function is_reentry(hold, claimant) {
+  return claimant !== UNNUMBERED_ISSUE && is_own_hold(hold, claimant);
+}
+function held_message(hold) {
+  return `This working tree is already held by ${describe_holder(hold)}. One run at a time per working tree: a second run here commits its files onto the other run's branch. If that record is stale, run \`${FORCE_RELEASE_COMMAND}\` in this working tree \u2014 it removes a record this run did not write, so be sure the run that did has ended \u2014 and ask again.`;
+}
+function foreign_release_message(hold) {
+  return `This working tree is held by ${describe_holder(hold)}, and this release did not claim it \u2014 nothing was removed. Release it as that run with \`${own_release_command(hold.issue)}\`, or, once you are sure it has ended, remove the record with \`${FORCE_RELEASE_COMMAND}\`.`;
+}
+function forced_release_message(hold) {
+  return `Forced: removed the run record held by ${describe_holder(hold)}.`;
+}
+function unreadable_message() {
+  return `This working tree's run record could not be read \u2014 ${NOT_IDLE}. Run \`${FORCE_RELEASE_COMMAND}\` in this working tree to clear it, then ask again.`;
+}
+function stale_reason(hold) {
+  return is_owner_gone(hold) ? "the session that wrote it has ended" : `older than ${String(HOLD_MAX_AGE_HOURS)} hours`;
+}
+function stale_message(hold) {
+  return `Replaced a stale run record held by ${describe_holder(hold)}: ${stale_reason(hold)}, so the run that wrote it has ended without releasing it.`;
+}
+function uncommitted_message(hold) {
+  return `This working tree still has uncommitted changes, and its run record \u2014 held by ${describe_holder(hold)} \u2014 has expired or outlived its session. That is a run which stopped for a person rather than one that finished, so the tree is not free: commit or stash the work, or run \`${own_release_command(hold.issue)}\` once you are done with it, then ask again.`;
+}
+function race_message(read, target) {
+  if (read.kind === "held") return held_message(read.hold);
+  return `A record already exists at ${target} and this run did not write it \u2014 ${NOT_IDLE}. Either another run claimed the tree at the same moment, or the record belongs to another account. Run \`${FORCE_RELEASE_COMMAND}\`, and remove that file by hand if it is still there.`;
+}
+function unknown_message() {
+  return `Could not read this working tree's git directory \u2014 ${NOT_IDLE}. Run this from inside the checkout the run will edit.`;
+}
+var run_hold = {
+  is_stop_marked,
+  FORCE_RELEASE_COMMAND,
+  HOLD_MAX_AGE_HOURS,
+  HOLD_MAX_AGE_MS,
+  RELEASE_COMMAND,
+  UNNUMBERED_ISSUE,
+  classify: classify2,
+  create_halfrun_stop_hold,
+  create_stop_hold,
+  HALFRUN_STOP_FIELDS,
+  create_hold,
+  describe_holder,
+  foreign_release_message,
+  forced_release_message,
+  held_message,
+  hold_path,
+  is_linked_worktree,
+  is_own_hold,
+  is_reentry,
+  is_tree_dirty,
+  own_release_command,
+  race_message,
+  read_hold,
+  release_hold,
+  session_owner,
+  stale_message,
+  stale_reason,
+  uncommitted_message,
+  unknown_message,
+  unreadable_message,
+  worktree_directory,
+  write_hold
+};
+
+export {
+  stamp_record,
+  run_hold
+};

package/dist/commands/chunk-NQFQVSHV.js

@@ -0,0 +1,56 @@
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/run/event/run-event-step.ts
+var TOTAL_STEPS = 8;
+var STEP_KIND = run_event_stream.EVENT_KIND.STEP;
+var STEP = {
+  UPDATE_DEPS: { number: 4, name: "update-deps" },
+  IMPLEMENT: { number: 5, name: "implement" },
+  GATE: { number: 6, name: "gate" },
+  FOLLOWUP: { number: 7, name: "followup" }
+};
+var WORD_SEPARATOR = " ";
+var WORDS_START = 1;
+var NAME_START = 3;
+function text_of(issue, step) {
+  const cite = issue_cite.plain_for("program", issue);
+  return `${cite} step ${String(step.number)}/${String(TOTAL_STEPS)} ${step.name}`;
+}
+function words_after(event, start) {
+  return event.text.split(WORD_SEPARATOR).slice(start).join(WORD_SEPARATOR);
+}
+function words_of(event) {
+  return words_after(event, WORDS_START);
+}
+function name_of(event) {
+  return words_after(event, NAME_START);
+}
+function is_step_of(event, issue) {
+  return event.kind === STEP_KIND && run_event_scope.issue_named(event) === issue;
+}
+function is_latest(events, issue, text) {
+  return events.findLast((event) => is_step_of(event, issue))?.text === text;
+}
+var STREAM_IO = {
+  read: run_event_stream_emit.all_events,
+  emit: run_event_stream_emit.emit
+};
+async function record(issue, step, io = STREAM_IO) {
+  const text = text_of(issue, step);
+  if (is_latest(await io.read(), issue, text)) return;
+  await io.emit(STEP_KIND, text);
+}
+var run_event_step = { STEP, name_of, record, text_of, words_of };
+
+export {
+  run_event_step
+};

package/dist/commands/chunk-NR4BD5DD.js

@@ -0,0 +1,38 @@
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/gate/moved-paths.ts
+var NAME_SEPARATOR = "\0";
+var BASE_DIFF = ["diff", "--name-only", "--no-renames", "-z"];
+async function base_diff(from, to) {
+  if (from === to) return [];
+  try {
+    const names = await git_spawn.read([...BASE_DIFF, from, to]);
+    return names.split(NAME_SEPARATOR).filter((name) => name !== "");
+  } catch {
+    return void 0;
+  }
+}
+async function moved_parts(stamp, tree) {
+  const is_unread = Object.keys(tree.files).length === 0;
+  if (is_unread || stamp.base === void 0 || tree.base === void 0) return void 0;
+  const synced = await base_diff(stamp.base, tree.base);
+  if (synced === void 0) return void 0;
+  return { changed: file_map_stamp.changed_since(stamp, tree.files), synced };
+}
+function union_of(parts) {
+  return [.../* @__PURE__ */ new Set([...parts.changed, ...parts.synced])];
+}
+async function moved_since(stamp, tree) {
+  const parts = await moved_parts(stamp, tree);
+  return parts === void 0 ? void 0 : union_of(parts);
+}
+var moved_paths = { moved_parts, moved_since, union_of };
+
+export {
+  moved_paths
+};