@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-BFKTUD3V.js

@@ -0,0 +1,33 @@
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec
+} from "./chunk-43DU7DYZ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/gh/gh-spawn.ts
+var NO_BUDGET = 0;
+function fetch_repo_name(timeout_ms) {
+  const stdout = git_gh_exec.read_gh_api_sync({
+    path: git_gh_api_path.repo_api_path(),
+    jq_filter: ".full_name",
+    cwd: PROJECT_ROOT,
+    timeout_ms: timeout_ms ?? NO_BUDGET
+  });
+  const name = stdout?.trim();
+  return name === "" ? void 0 : name;
+}
+function get_repo_name_with_owner() {
+  return fetch_repo_name(void 0);
+}
+function get_repo_name_with_owner_within(timeout_ms) {
+  return fetch_repo_name(timeout_ms);
+}
+var gh_spawn = { get_repo_name_with_owner, get_repo_name_with_owner_within };
+
+export {
+  gh_spawn
+};

package/dist/commands/chunk-BLRXHK2V.js

@@ -0,0 +1,17 @@
+import {
+  issue_state_cli
+} from "./chunk-E4PFCTXN.js";
+import {
+  has_parked_label
+} from "./chunk-QQBMVC5W.js";
+
+// scripts/lane/lane-parked.ts
+async function is_parked(issue) {
+  const read = await issue_state_cli.read_issue(issue);
+  return read.kind === "state" && has_parked_label(read.state.labels);
+}
+var lane_parked = { is_parked };
+
+export {
+  lane_parked
+};

package/dist/commands/chunk-BLUAO4QW.js

@@ -0,0 +1,173 @@
+import {
+  run_ship_probe
+} from "./chunk-374XGAWD.js";
+import {
+  run_ship_detach
+} from "./chunk-FJM2HWKW.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/ship/run-ship-wait-cli.ts
+import { setTimeout as sleep2 } from "node:timers/promises";
+
+// scripts/run/ship/run-ship-waiter.ts
+import { setTimeout as sleep } from "node:timers/promises";
+import { z } from "zod";
+var HEARTBEAT_PREFIX = "josh-ship-waiter-";
+var HANDOFF_PREFIX = "josh-ship-handoff-";
+var DECISION_PREFIX = "josh-ship-handoff-taken-";
+var KEY_SEPARATOR = "-";
+var TAKEN = "taken";
+var WITHDRAWN = "withdrawn";
+var SESSION_GAP_MS = 12e4;
+var OFFER_POLL_MS = 1e3;
+var heartbeat_schema = z.object({ at: z.number() });
+var offer_schema = z.object({ at: z.number(), note: z.string() });
+function path_of(prefix, repository, issue) {
+  return stamp_file.stamp_path(`${prefix}${issue}${KEY_SEPARATOR}`, repository);
+}
+function beat(repository, issue, at = Date.now()) {
+  stamp_file.replace_stamp(path_of(HEARTBEAT_PREFIX, repository, issue), { at });
+}
+function leave(repository, issue) {
+  stamp_file.remove_stamp(path_of(HEARTBEAT_PREFIX, repository, issue));
+}
+function is_waited(repository, issue, now = Date.now()) {
+  const raw = stamp_file.read_stamp_text(path_of(HEARTBEAT_PREFIX, repository, issue));
+  const heartbeat = raw === void 0 ? void 0 : json_value.parse_with(raw, heartbeat_schema);
+  return heartbeat !== void 0 && now - heartbeat.at < SESSION_GAP_MS;
+}
+function decide(repository, issue, decision) {
+  return stamp_file.create_stamp(path_of(DECISION_PREFIX, repository, issue), decision);
+}
+function clear_offer(repository, issue) {
+  stamp_file.remove_stamp(path_of(HANDOFF_PREFIX, repository, issue));
+  stamp_file.remove_stamp(path_of(DECISION_PREFIX, repository, issue));
+}
+function offered_note(repository, issue, now) {
+  const raw = stamp_file.read_stamp_text(path_of(HANDOFF_PREFIX, repository, issue));
+  const offered = raw === void 0 ? void 0 : json_value.parse_with(raw, offer_schema);
+  return offered !== void 0 && now - offered.at < SESSION_GAP_MS ? offered.note : void 0;
+}
+function take(repository, issue, now = Date.now()) {
+  const note = offered_note(repository, issue, now);
+  if (note === void 0 || !decide(repository, issue, TAKEN)) return void 0;
+  stamp_file.remove_stamp(path_of(HANDOFF_PREFIX, repository, issue));
+  return note;
+}
+async function await_taken(repository, issue) {
+  const decision = path_of(DECISION_PREFIX, repository, issue);
+  const is_taken = await poll.poll_until(() => stamp_file.read_stamp_text(decision) !== void 0, {
+    attempts: Math.ceil(SESSION_GAP_MS / OFFER_POLL_MS),
+    interval_ms: OFFER_POLL_MS,
+    sleeper: sleep
+  });
+  if (is_taken) return true;
+  await sleep(OFFER_POLL_MS);
+  return !decide(repository, issue, WITHDRAWN);
+}
+async function offer(repository, issue, note) {
+  if (!is_waited(repository, issue)) return false;
+  clear_offer(repository, issue);
+  stamp_file.replace_stamp(path_of(HANDOFF_PREFIX, repository, issue), { at: Date.now(), note });
+  const is_taken = await await_taken(repository, issue);
+  stamp_file.remove_stamp(path_of(HANDOFF_PREFIX, repository, issue));
+  return is_taken;
+}
+var run_ship_waiter = { SESSION_GAP_MS, beat, is_waited, leave, offer, take };
+
+// scripts/run/ship/run-ship-wait-cli.ts
+var VERDICT = {
+  RETURNED: "returned",
+  PASSED: "passed",
+  ENDED: "ended",
+  PENDING: "pending"
+};
+var CHUNK_MS = 27e4;
+var POLL_MS = 2e3;
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var USAGE = "Usage: josh ship:wait <N>";
+var NO_REPOSITORY_NOTE = "not inside a git repository";
+var { COMMIT, FOLLOWUP, REPORT } = run_ship_stage.STAGE;
+var PAST_COMMIT = /* @__PURE__ */ new Set([FOLLOWUP, REPORT]);
+function is_committed(repository, issue) {
+  const target = run_ship_stage.record_path(repository, issue);
+  const started = run_ship_stage.read_started(target);
+  if (started.some((stage) => PAST_COMMIT.has(stage))) return true;
+  return started.includes(COMMIT) && run_ship_stage.read_done(target).has(COMMIT);
+}
+function ended(repository, issue) {
+  const result = run_ship_detach.read_result(repository, issue)?.result;
+  if (result === "running") return void 0;
+  return { verdict: result === "success" ? VERDICT.PASSED : VERDICT.ENDED };
+}
+function settled(repository, issue) {
+  const note = run_ship_waiter.take(repository, issue);
+  if (note !== void 0) return { verdict: VERDICT.RETURNED, note };
+  if (is_committed(repository, issue)) return { verdict: VERDICT.PASSED };
+  return ended(repository, issue);
+}
+async function wait_within(repository, issue, deadline) {
+  return await poll.wait_for(
+    () => {
+      if (Date.now() >= deadline) return { verdict: VERDICT.PENDING };
+      run_ship_waiter.beat(repository, issue);
+      return settled(repository, issue);
+    },
+    { interval_ms: POLL_MS, sleeper: sleep2 }
+  );
+}
+async function wait_for(repository, issue, chunk_ms = CHUNK_MS) {
+  const waited = await wait_within(repository, issue, Date.now() + chunk_ms);
+  if (waited.verdict !== VERDICT.PENDING) run_ship_waiter.leave(repository, issue);
+  return waited;
+}
+function chunk_left() {
+  return CHUNK_MS - performance.now();
+}
+function next_action(issue) {
+  return {
+    [VERDICT.RETURNED]: "the ship stopped: fix what the note below says, then ship again",
+    [VERDICT.PASSED]: "the supervisor ships the rest: end the turn",
+    [VERDICT.ENDED]: "nothing is left to wait for: end the turn",
+    [VERDICT.PENDING]: `still before the commit: on \`pnpm josh cost --cut\` \`under\`, run \`pnpm josh ship:wait ${issue}\` again; else end the turn`
+  };
+}
+function report(issue, waited) {
+  console.info(`${waited.verdict} \u2014 ${next_action(issue)[waited.verdict]}`);
+  if (waited.note !== void 0) console.info(waited.note);
+}
+async function run(argv) {
+  const issue = issue_number_shape.single_of(argv);
+  if (issue === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  const repository = await run_ship_probe.repository_directory();
+  if (repository === void 0) {
+    console.error(NO_REPOSITORY_NOTE);
+    return FAILURE_EXIT_CODE;
+  }
+  report(issue, await wait_for(repository, issue, chunk_left()));
+  return SUCCESS_EXIT_CODE;
+}
+var run_ship_wait_cli = { CHUNK_MS, VERDICT, run, wait_for };
+
+export {
+  run_ship_waiter,
+  run_ship_wait_cli
+};

package/dist/commands/chunk-BML6MEUB.js

@@ -0,0 +1,326 @@
+import {
+  epic_cross_repo
+} from "./chunk-YTXCLGGL.js";
+import {
+  issue_sample_prime
+} from "./chunk-WWLCQREY.js";
+import {
+  epic_issue
+} from "./chunk-YEAE46TS.js";
+import {
+  git_gh_issue_batch_graphql,
+  git_gh_issue_batch_read
+} from "./chunk-HYE3MBAN.js";
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  shared_cache
+} from "./chunk-WXLW7S4M.js";
+import {
+  author_fields_schema
+} from "./chunk-34DND4BA.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/epic/epic-child-source.ts
+import { z } from "zod";
+var HOURS_KEPT = 6;
+var MS_PER_HOUR = 36e5;
+var CLOSED_CACHE = { prefix: "josh-epic-closed-", ttl_ms: HOURS_KEPT * MS_PER_HOUR };
+var reference_schema = z.object({ repo: z.string(), number: z.number() });
+var child_schema = z.object({
+  number: z.number(),
+  repo: z.string(),
+  state: z.enum(["OPEN", "CLOSED"]),
+  labels: z.array(z.string()),
+  blocked_by: z.array(reference_schema),
+  body: z.string().optional(),
+  ...author_fields_schema
+});
+var entries_schema = z.array(z.object({ read_at: z.number(), child: child_schema }));
+function fresh_entries(repo, now_ms) {
+  const entries = shared_cache.read(CLOSED_CACHE, repo, entries_schema, now_ms) ?? [];
+  return entries.filter((entry) => now_ms - entry.read_at < CLOSED_CACHE.ttl_ms);
+}
+function cached_closed(repo, now_ms) {
+  return new Map(fresh_entries(repo, now_ms).map((entry) => [entry.child.number, entry.child]));
+}
+function known(source, repo, now_ms) {
+  if (source === void 0) return /* @__PURE__ */ new Map();
+  const closed = cached_closed(repo, now_ms);
+  return source.repo === repo ? new Map([...closed, ...source.listed]) : closed;
+}
+function is_closed(child) {
+  return child.state === epic_issue.CLOSED;
+}
+function remember_closed(source, repo, children, now_ms) {
+  if (source === void 0) return;
+  const fresh = fresh_entries(repo, now_ms);
+  const reopened = new Set(
+    children.filter((child) => !is_closed(child)).map((child) => child.number)
+  );
+  const kept = fresh.filter((entry) => !reopened.has(entry.child.number));
+  const cached = new Set(kept.map((entry) => entry.child.number));
+  const added = children.filter((child) => is_closed(child) && !cached.has(child.number));
+  if (added.length === 0 && kept.length === fresh.length) return;
+  const entries = [...kept, ...added.map((child) => ({ read_at: now_ms, child }))];
+  shared_cache.write(CLOSED_CACHE, repo, entries, now_ms);
+}
+function waited_closed(children, known_children, repo) {
+  const waited = children.filter((child) => !is_closed(child)).flatMap((child) => child.blocked_by).filter((blocker) => blocker.repo === repo).map((blocker) => blocker.number);
+  return new Set(waited.filter((number) => known_children.get(number)?.state === epic_issue.CLOSED));
+}
+var epic_child_source = { CLOSED_CACHE, known, remember_closed, waited_closed };
+
+// scripts/epic/epic-relation-recheck.ts
+var RECHECK_LIMIT = 20;
+function suspect_children(children, body, declared_repo) {
+  const links = epic_parse.parse_dependency_links(body);
+  const local = children.filter((child) => child.repo === declared_repo);
+  return new Set(
+    epic_graph.missing_relations(links, local, declared_repo).map((link) => link.blocked)
+  );
+}
+async function reread_child(child, read_blockers) {
+  try {
+    return { ...child, blocked_by: await read_blockers(child) };
+  } catch (error) {
+    const reason = error_text.message_of(error);
+    console.warn(
+      `\u26A0 could not re-read the blockers of ${session_cite.issue(child.number, void 0, child.repo)}: ${reason}
+  a mismatch reported below may be this read failing rather than a missing relation`
+    );
+    return child;
+  }
+}
+function skipped_over_limit(children, suspect_count) {
+  console.warn(
+    `\u26A0 ${String(suspect_count)} declared links are unrecorded, past the ${String(RECHECK_LIMIT)} this re-reads
+  the mismatch below is reported from the first read; the body is likely ahead of the relations`
+  );
+  return children;
+}
+async function recheck_missing_relations(children, body, declared_repo, read_blockers) {
+  const suspects = suspect_children(children, body, declared_repo);
+  if (suspects.size === 0) return children;
+  if (suspects.size > RECHECK_LIMIT) return skipped_over_limit(children, suspects.size);
+  return await Promise.all(
+    children.map(
+      async (child) => suspects.has(child.number) && child.repo === declared_repo ? await reread_child(child, read_blockers) : child
+    )
+  );
+}
+var epic_relation_recheck = { recheck_missing_relations, RECHECK_LIMIT };
+
+// scripts/epic/epic-fetch.ts
+var CHILD_LIMIT = 200;
+function to_child(parsed, repo) {
+  return {
+    number: parsed.number,
+    repo,
+    state: epic_issue.normalize_state(parsed.state),
+    labels: epic_issue.label_names(parsed),
+    blocked_by: epic_issue.blocker_references_of(parsed, repo),
+    body: parsed.body,
+    author_association: parsed.author_association,
+    user: parsed.user
+  };
+}
+function scope_for(child_repo, current_repo) {
+  return child_repo === current_repo ? void 0 : child_repo;
+}
+async function read_child_blockers(child, current_repo) {
+  return await git_gh_command.issue_blocked_by_references(
+    String(child.number),
+    child.repo,
+    scope_for(child.repo, current_repo)
+  );
+}
+async function fetch_epic_body(epic_number, scope) {
+  const read = await git_gh_command.issue_get_body_classified(String(epic_number), scope);
+  const body = read.kind === "read" ? read.text : void 0;
+  return {
+    body,
+    body_failure: read.kind === "read" ? void 0 : read,
+    child_numbers: epic_parse.parse_task_list_issue_numbers(body),
+    external: epic_parse.parse_external_task_list_children(body)
+  };
+}
+async function rechecked_children(children, snapshot) {
+  return await epic_relation_recheck.recheck_missing_relations(
+    children,
+    snapshot.body,
+    snapshot.repo,
+    async (child) => await read_child_blockers(child, snapshot.current_repo)
+  );
+}
+function to_references(issue_numbers, repo) {
+  return issue_numbers.map((issue_number) => ({ repo, number: issue_number }));
+}
+var NOT_READ = { child: void 0, is_unreachable: false };
+async function read_rest(issue_number, scope) {
+  return await git_gh_command.issue_get_state_and_relations_classified(String(issue_number), scope);
+}
+async function to_child_read(read, repo) {
+  if (read.kind !== "read") {
+    return { child: void 0, is_unreachable: git_gh_command.is_unreachable_read(read) };
+  }
+  const parsed = epic_issue.parse_epic_issue(read.json);
+  await issue_sample_prime.prime([parsed?.body]);
+  return { child: parsed === void 0 ? void 0 : to_child(parsed, repo), is_unreachable: false };
+}
+async function read_children(issue_numbers, repo, scope) {
+  const reads = await git_gh_issue_batch_read.read_each(issue_numbers, {
+    repo: scope,
+    from_json: git_gh_issue_batch_graphql.answered,
+    read_rest: async (issue_number) => await read_rest(issue_number, scope)
+  });
+  const entries = await Promise.all(
+    reads.map(async ([issue_number, read]) => [
+      issue_number,
+      await to_child_read(read, repo)
+    ])
+  );
+  return new Map(entries);
+}
+async function fetch_child(issue_number, repo, scope) {
+  const read = await to_child_read(await read_rest(issue_number, scope), repo);
+  return read.child;
+}
+function to_children(reads) {
+  return reads.map((read) => read.child).filter((child) => child !== void 0);
+}
+function count_unreachable(reads) {
+  return reads.filter((read) => read.is_unreachable).length;
+}
+function is_body_unreachable(failure) {
+  return failure !== void 0 && git_gh_command.is_unreachable_read(failure);
+}
+async function known_or_read(issue_number, known2, fresh) {
+  const child = known2.get(issue_number);
+  if (child === void 0) return fresh.get(issue_number) ?? NOT_READ;
+  await issue_sample_prime.prime([child.body]);
+  return { child, is_unreachable: false };
+}
+async function answer_children(issue_numbers, known2, repo, scope) {
+  const unknown = issue_numbers.filter((issue_number) => !known2.has(issue_number));
+  const fresh = await read_children(unknown, repo, scope);
+  return await Promise.all(
+    issue_numbers.map(async (issue_number) => await known_or_read(issue_number, known2, fresh))
+  );
+}
+async function recheck_blockers(reads, child_numbers, known2, repo) {
+  const waited = epic_child_source.waited_closed(to_children(reads), known2, repo);
+  if (waited.size === 0) return reads;
+  const fresh = await read_children([...waited], repo);
+  return reads.map((read, index) => fresh.get(child_numbers[index] ?? 0) ?? read);
+}
+async function fetch_children(child_numbers, repo, scope, source) {
+  const limited = child_numbers.slice(0, CHILD_LIMIT);
+  const now_ms = Date.now();
+  const known2 = epic_child_source.known(source, repo, now_ms);
+  const answered = await answer_children(limited, known2, repo, scope);
+  const reads = await recheck_blockers(answered, limited, known2, repo);
+  epic_child_source.remember_closed(source, repo, to_children(reads), now_ms);
+  return {
+    children: to_children(reads),
+    unreadable: to_references(
+      limited.filter((_, index) => reads[index]?.child === void 0),
+      repo
+    ),
+    skipped: to_references(child_numbers.slice(CHILD_LIMIT), repo),
+    unreachable_count: count_unreachable(reads)
+  };
+}
+async function read_external(allowed) {
+  const repos = [...new Set(allowed.map((child) => child.repo))];
+  const batches = await Promise.all(
+    repos.map(async (repo) => {
+      const issue_numbers = allowed.filter((child) => child.repo === repo).map((child) => child.number);
+      return await read_children(issue_numbers, repo, repo);
+    })
+  );
+  return allowed.map((child) => batches[repos.indexOf(child.repo)]?.get(child.number) ?? NOT_READ);
+}
+async function fetch_external_children(external, current_owner) {
+  const allowed = external.filter(
+    (child) => epic_cross_repo.is_same_owner_repo(child.repo, current_owner)
+  );
+  const reads = await read_external(allowed);
+  const refused = external.filter(
+    (child) => !epic_cross_repo.is_same_owner_repo(child.repo, current_owner)
+  );
+  return {
+    children: to_children(reads),
+    unreadable: [...allowed.filter((_, index) => reads[index]?.child === void 0), ...refused],
+    skipped: [],
+    // A refusal is not a transport failure: the owner restriction answers the same tomorrow.
+    unreachable_count: count_unreachable(reads)
+  };
+}
+function to_failure_counts(body_failure, groups) {
+  const body_failed = body_failure === void 0 ? 0 : 1;
+  return {
+    failed: body_failed + groups.reduce((total, group) => total + group.unreadable.length, 0),
+    unreachable: (is_body_unreachable(body_failure) ? 1 : 0) + groups.reduce((total, group) => total + group.unreachable_count, 0)
+  };
+}
+function is_snapshot_unreachable(body_failure, groups) {
+  const counts = to_failure_counts(body_failure, groups);
+  return counts.failed > 0 && counts.failed === counts.unreachable;
+}
+async function to_snapshot(epic_body, scope, local, remote) {
+  const { body, body_failure, child_numbers, external } = epic_body;
+  const children = await rechecked_children([...local.children, ...remote.children], {
+    body,
+    ...scope
+  });
+  return {
+    body,
+    repo: scope.repo,
+    current_repo: scope.current_repo,
+    children,
+    child_numbers: [...child_numbers, ...external.map((child) => child.number)],
+    unreadable: [...local.unreadable, ...remote.unreadable],
+    skipped: local.skipped,
+    has_external_children: external.length > 0,
+    body_failure,
+    is_unreachable: is_snapshot_unreachable(body_failure, [local, remote])
+  };
+}
+async function fetch_epic(epic_number, repo, current_repo = repo, source) {
+  const scope = scope_for(repo, current_repo);
+  const epic_body = await fetch_epic_body(epic_number, scope);
+  const owner = epic_cross_repo.owner_of(current_repo);
+  const local = await fetch_children(epic_body.child_numbers, repo, scope, source);
+  const remote = await fetch_external_children(epic_body.external, owner);
+  return await to_snapshot(epic_body, { repo, current_repo }, local, remote);
+}
+function missing_children(snapshot) {
+  return [...snapshot.unreadable, ...snapshot.skipped];
+}
+var epic_fetch = {
+  CHILD_LIMIT,
+  scope_for,
+  read_child_blockers,
+  missing_children,
+  fetch_child,
+  fetch_children,
+  fetch_external_children,
+  fetch_epic
+};
+
+export {
+  epic_fetch
+};

package/dist/commands/chunk-BPDNGJXY.js

@@ -0,0 +1,63 @@
+import {
+  backlog_budget
+} from "./chunk-BYSPYVLD.js";
+import {
+  stamp_record
+} from "./chunk-F5N2QIFD.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/park/run-park.ts
+import { z } from "zod";
+var PARK_PREFIX = "josh-run-park-";
+var PARK_MAX_AGE_MS = backlog_budget.DEFAULT_IDLE_MS;
+var run_park_schema = z.object({
+  issue: z.string(),
+  parked_at: z.string()
+});
+function parse_park(raw) {
+  return json_value.parse_with(raw, run_park_schema);
+}
+function parked_at_of(park) {
+  return park.parked_at;
+}
+var PARK_SPEC = {
+  parse: parse_park,
+  timestamp_of: parked_at_of,
+  max_age_ms: PARK_MAX_AGE_MS
+};
+function park_path(repository, issue) {
+  return stamp_file.stamp_path(`${PARK_PREFIX}${issue}-`, repository);
+}
+function record(issue, directory, now = /* @__PURE__ */ new Date()) {
+  const repository = git_common_directory.repository(directory);
+  if (repository === void 0) return false;
+  stamp_file.replace_stamp(park_path(repository, issue), { issue, parked_at: now.toISOString() });
+  return true;
+}
+function clear(issue, directory) {
+  const repository = git_common_directory.repository(directory);
+  if (repository !== void 0) stamp_file.remove_stamp(park_path(repository, issue));
+}
+function is_parked_sync(issue, directory, now = /* @__PURE__ */ new Date()) {
+  const repository = git_common_directory.repository(directory);
+  if (repository === void 0) return false;
+  const read = stamp_record.classify(
+    stamp_file.read_stamp_text(park_path(repository, issue)),
+    PARK_SPEC,
+    now
+  );
+  return read.kind === "carried" && read.record.issue === issue;
+}
+var run_park = { PARK_MAX_AGE_MS, clear, is_parked_sync, record };
+
+export {
+  run_park
+};