@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-A3LCN4KA.js

@@ -0,0 +1,84 @@
+import {
+  backlog_next
+} from "./chunk-YNCF66RK.js";
+import {
+  backlog_wait_cause
+} from "./chunk-N2ZF6T4E.js";
+import {
+  josh_command
+} from "./chunk-47J4KOZP.js";
+import {
+  shared_cache
+} from "./chunk-WXLW7S4M.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  run_startup
+} from "./chunk-RV7EQIE4.js";
+
+// scripts/backlog/backlog-next-shared.ts
+import { z } from "zod";
+var SUCCESS_EXIT_CODE = 0;
+var NEXT_CACHE = { prefix: "josh-backlog-next-", ttl_ms: 6e4 };
+var result_schema = z.object({
+  code: z.number(),
+  out: z.string(),
+  err: z.string().exactOptional()
+});
+async function stream_key(scope) {
+  const target = await run_event_stream_emit.stream_target();
+  const last = target === void 0 ? void 0 : run_event_stream.read_last(target);
+  return JSON.stringify({ argv: scope, last });
+}
+function is_kept(result) {
+  if (result.code !== SUCCESS_EXIT_CODE) return false;
+  return !result.out.split("\n").includes(backlog_next.VERDICT_TOKENS.retry);
+}
+function edge_of(result) {
+  const [token = ""] = result.out.split("\n", 1);
+  const { error, retry, wait, stop, triage } = backlog_next.VERDICT_TOKENS;
+  const is_failed = [error, retry].includes(token);
+  if (is_failed || result.code !== SUCCESS_EXIT_CODE) return "failed";
+  return [wait, stop, triage].includes(token) ? "waiting" : "done";
+}
+function replay(result, should_forward_stderr) {
+  if (should_forward_stderr && result.err !== void 0 && result.err !== "") {
+    console.error(result.err);
+  }
+  return result;
+}
+function wait_deadline(kept) {
+  if (kept?.out.trim() !== backlog_next.VERDICT_TOKENS.wait) return void 0;
+  return backlog_wait_cause.parse(kept.err ?? "").not_before_ms;
+}
+function kept_until(key, now_ms) {
+  const kept = shared_cache.read(NEXT_CACHE, key, result_schema, now_ms);
+  const deadline = wait_deadline(kept);
+  if (deadline !== void 0) return deadline > now_ms ? kept : void 0;
+  return kept;
+}
+async function read(argv, should_forward_stderr = false, timeout_ms) {
+  const key = await stream_key(argv);
+  const now_ms = Date.now();
+  const kept = kept_until(key, now_ms);
+  if (kept !== void 0) return replay(kept, should_forward_stderr);
+  const result = await run_startup.phase(
+    "candidate cache fill",
+    async () => {
+      run_startup.metric("cache", "fill", `${NEXT_CACHE.prefix}:${key}`);
+      return await josh_command.josh_run(argv, should_forward_stderr, timeout_ms);
+    },
+    { edge_of }
+  );
+  if (is_kept(result)) shared_cache.write(NEXT_CACHE, key, result, now_ms);
+  return result;
+}
+var backlog_next_shared = { NEXT_CACHE, edge_of, read, stream_key };
+
+export {
+  backlog_next_shared
+};

package/dist/commands/chunk-ABLXBG6C.js

@@ -0,0 +1,98 @@
+import {
+  git_gh_issue
+} from "./chunk-NRULNBYI.js";
+import {
+  git_gh_issue_rest
+} from "./chunk-TFYYXETQ.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  AUTO_OK_LABEL,
+  IN_PROGRESS_LABEL
+} from "./chunk-QQBMVC5W.js";
+
+// scripts/backlog/backlog-drive-listing.ts
+import { z } from "zod";
+var labels_schema = z.array(z.looseObject({ name: z.string() })).catch([]);
+function labels_of(issue) {
+  return labels_schema.parse(issue["labels"]).map((label) => label.name);
+}
+function listing_of(body) {
+  const issues = git_gh_issue_rest.parse_rest_issues(body);
+  const listed = issues.filter((issue) => !git_gh_issue_rest.is_pull_request(issue)).map((issue) => ({ number: issue.number, labels: labels_of(issue) })).filter((issue) => !issue.labels.includes(IN_PROGRESS_LABEL));
+  return new Map(
+    listed.map((issue) => [
+      issue.number,
+      issue.labels.toSorted((left, right) => left.localeCompare(right)).join(",")
+    ])
+  );
+}
+function has_change(seen, listing) {
+  if (seen === void 0) return false;
+  return [...listing].some(([number, labels]) => seen.get(number) !== labels);
+}
+function watcher() {
+  const memory = {};
+  function keep(listing) {
+    memory.seen = listing;
+  }
+  return async function is_changed() {
+    try {
+      const detail = await git_gh_issue.issue_list_label_first_page(AUTO_OK_LABEL);
+      const listing = listing_of(detail.body);
+      const is_new = has_change(memory.seen, listing);
+      keep(listing);
+      return is_new;
+    } catch {
+      keep(memory.seen ?? /* @__PURE__ */ new Map());
+      return false;
+    }
+  };
+}
+var backlog_drive_listing = {
+  watcher
+};
+
+// scripts/backlog/backlog-arrival-added.ts
+async function read_stream() {
+  const target = await run_event_stream_emit.stream_target();
+  return target === void 0 ? [] : run_event_stream.read_events(target);
+}
+function has_kind_since(events, kind, since_ms) {
+  return events.some((event) => event.kind === kind && Date.parse(event.at) >= since_ms);
+}
+async function is_kind_since(kind, since_ms, read) {
+  try {
+    return has_kind_since(await read(), kind, since_ms);
+  } catch {
+    return false;
+  }
+}
+async function is_added_since(since_ms, read = read_stream) {
+  return await is_kind_since(run_event_stream.EVENT_KIND.ADD, since_ms, read);
+}
+async function is_raised_since(since_ms, read = read_stream) {
+  return await is_kind_since(run_event_stream.EVENT_KIND.LANE_LIMIT, since_ms, read);
+}
+function tick_reader(read = read_stream) {
+  const memo = { pending: void 0 };
+  return {
+    read: async () => {
+      memo.pending ??= read();
+      return await memo.pending;
+    },
+    begin_tick: () => {
+      memo.pending = void 0;
+    }
+  };
+}
+var backlog_arrival_added = { has_kind_since, is_added_since, is_raised_since, tick_reader };
+
+export {
+  backlog_drive_listing,
+  backlog_arrival_added
+};

package/dist/commands/chunk-ABM2MZBF.js

@@ -0,0 +1,161 @@
+import {
+  epic_blocked_by
+} from "./chunk-TMFKVJUW.js";
+import {
+  stash_push_cli
+} from "./chunk-UVY5ODCM.js";
+import {
+  main_merge_guard
+} from "./chunk-HE3GOMR7.js";
+import {
+  run_hold_cli
+} from "./chunk-YD7XK2TX.js";
+import {
+  run_pause_comment
+} from "./chunk-YNCF66RK.js";
+import {
+  git_stash
+} from "./chunk-WROJTXWZ.js";
+import {
+  git_gh_issue_write
+} from "./chunk-4F4KARQN.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/run/pause/run-set-aside-commit.ts
+var COMMAND = "run:pause";
+var RERUN = "the command that paused (`run:pause`, `run:split`)";
+var COMMITTED_VERDICT = "committed";
+var CLEAN_VERDICT = "clean";
+var ALREADY = "already";
+async function is_lane(issue) {
+  return await git_command.branch() === lane_paths.lane_branch(issue);
+}
+function message_of(stash_message) {
+  return `wip: ${stash_message}`;
+}
+async function is_committed(stash_message) {
+  return await git_spawn.read(["log", "-1", "--format=%s"]) === message_of(stash_message);
+}
+async function commit(stash_message) {
+  if (await is_committed(stash_message)) return ALREADY;
+  const unmerged = await git_stash.unmerged_paths();
+  if (unmerged.length > 0) {
+    throw new Error(main_merge_guard.unresolved_message(COMMAND, unmerged, RERUN));
+  }
+  if (!await git_stash.has_stashable_changes()) return CLEAN_VERDICT;
+  await git_spawn.read(["add", "-A", "--", ":/"]);
+  await git_spawn.read(["commit", "--no-verify", "-m", message_of(stash_message)]);
+  return COMMITTED_VERDICT;
+}
+var run_set_aside_commit = { is_lane, is_committed, message_of, commit };
+
+// scripts/run/pause/run-set-aside.ts
+var SUCCESS_EXIT_CODE = 0;
+var ALREADY2 = "already";
+async function is_stashed(request) {
+  return git_stash.select(await git_stash.list(), request.stash_message).kind !== "none";
+}
+async function stash(request) {
+  if (await is_stashed(request)) return ALREADY2;
+  return await stash_push_cli.set_aside({ message: request.stash_message, dir: void 0 });
+}
+async function is_committed_aside(request) {
+  if (request.is_handed_off === true) return false;
+  return await run_set_aside_commit.is_lane(request.issue);
+}
+async function set_aside(request) {
+  if (!await is_committed_aside(request)) return await stash(request);
+  return await run_set_aside_commit.commit(request.stash_message);
+}
+var NOTHING_SET_ASIDE = "- The tree held no uncommitted work, so nothing was set aside.";
+function committed_line(request) {
+  const message = run_set_aside_commit.message_of(request.stash_message);
+  return `- The work in progress was committed on the lane branch as \`${message}\`. To resume, run \`pnpm josh main:merge\` on the lane and continue.`;
+}
+function stashed_line(request) {
+  return `- The work in progress was stashed. After \`pnpm josh ms\`, recover it with \`pnpm josh stash:pop "${request.stash_message}"\`.`;
+}
+async function work_line(request) {
+  if (await is_committed_aside(request)) {
+    const is_committed2 = await run_set_aside_commit.is_committed(request.stash_message);
+    return is_committed2 ? committed_line(request) : NOTHING_SET_ASIDE;
+  }
+  return await is_stashed(request) ? stashed_line(request) : NOTHING_SET_ASIDE;
+}
+async function comment(request) {
+  if (await run_pause_comment.has_comment(request)) return ALREADY2;
+  const body = [request.headline, await work_line(request), request.marker].join("\n");
+  return await git_gh_issue_write.issue_comment(request.issue, body);
+}
+async function release(issue) {
+  const code = await run_hold_cli.run(["--release", issue]);
+  if (code !== SUCCESS_EXIT_CODE) throw new Error("`run:release` refused");
+  return "released";
+}
+async function attempt(act) {
+  try {
+    return { detail: await act() };
+  } catch (error) {
+    return { reason: error_text.message_of(error) };
+  }
+}
+async function run_steps(steps) {
+  const done = [];
+  for (const [step, act] of steps) {
+    const outcome = await attempt(act);
+    if ("reason" in outcome) return { kind: "failed", step, reason: outcome.reason, done };
+    done.push({ step, detail: outcome.detail });
+  }
+  return { kind: "done", done };
+}
+function steps_of(request, between = []) {
+  return [
+    ["set-aside", async () => await set_aside(request)],
+    ["comment", async () => await comment(request)],
+    ...between,
+    ["release", async () => await release(request.issue)]
+  ];
+}
+var run_set_aside = { steps_of, run_steps };
+
+// scripts/run/pause/run-pause.ts
+function aside_of(request) {
+  const issue = issue_cite.plain_for("program", request.issue);
+  const prerequisite = issue_cite.plain_for("program", request.prerequisite);
+  return {
+    issue: request.issue,
+    stash_message: `run:pause: ${issue} waits on ${prerequisite}`,
+    marker: `${run_pause_comment.marker_of(request.issue)}${prerequisite} -->`,
+    headline: `Paused: ${prerequisite} has to land first.`
+  };
+}
+var NO_STEPS = { before: [], after: [] };
+async function pause(request, around = NO_STEPS) {
+  const steps = run_set_aside.steps_of(aside_of(request), [
+    ...around.before,
+    ["blocked-by", async () => await epic_blocked_by.record(request)],
+    ...around.after
+  ]);
+  const result = await run_set_aside.run_steps(steps);
+  return result.kind === "done" ? { kind: "paused", done: result.done } : result;
+}
+var run_pause = { pause, aside_of };
+
+export {
+  run_set_aside,
+  run_pause
+};

package/dist/commands/chunk-AN7BFVHU.js

@@ -0,0 +1,244 @@
+import {
+  epic_add_body,
+  epic_chains,
+  epic_read,
+  epic_shape
+} from "./chunk-MOD3FG4V.js";
+import {
+  epic_decision
+} from "./chunk-XSKB6ZUA.js";
+import {
+  epic_relations
+} from "./chunk-WTIPX5NG.js";
+import {
+  size_estimate
+} from "./chunk-2VY7CJ2R.js";
+import {
+  chain_links,
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  format_dependency_link,
+  format_dependency_links
+} from "./chunk-2ADQ5XRD.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  issue_read
+} from "./chunk-3F3RNIG2.js";
+import {
+  NEEDS_DECISION_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/epic/epic-decide.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+function format_list(numbers) {
+  return numbers.map((issue_number) => session_cite.issue(issue_number)).join(", ");
+}
+function untracked_error(epic_number, untracked) {
+  return `${format_list(untracked)} not tracked by ${session_cite.issue(epic_number)}; place it with \`pnpm josh epic --add ${String(epic_number)} <N> --decision-file <path>\`. Nothing was written.`;
+}
+function size_error(input) {
+  if (input.children.length === 1 || size_estimate.stated_line(input.decision) === void 0) {
+    return void 0;
+  }
+  return `The record states a size estimate but names ${format_list(input.children)}; an estimate is one child's, so record it with \`--decide\` for that child alone. Nothing was written.`;
+}
+async function read_decision_target(input) {
+  const record_error = epic_decision.find_decision_error(input.decision) ?? size_error(input);
+  if (record_error !== void 0) return { error: record_error };
+  const subject = await epic_read.read_subject(input.epic_number);
+  if (subject === void 0) {
+    return { error: `Could not read issue ${session_cite.issue(input.epic_number)}.` };
+  }
+  const tracked = epic_parse.parse_task_list_issue_numbers(subject.body);
+  const untracked = input.children.filter((child) => !tracked.includes(child));
+  return untracked.length === 0 ? subject : { error: untracked_error(input.epic_number, untracked) };
+}
+async function record_on_epic(subject, decision) {
+  const epic = session_cite.issue(subject.number);
+  if (epic_decision.has_decision(subject.body, decision)) {
+    return `\u{1F4DD} ${epic} already records this decision.`;
+  }
+  const body = epic_decision.append_decision(subject.body ?? "", decision);
+  await git_gh_command.issue_edit_body(String(subject.number), body);
+  return `\u{1F4DD} Decision recorded in ${epic}'s \`## Decisions\`.`;
+}
+async function has_comment(child, decision) {
+  const comments = await issue_read.parse_comments(
+    await git_gh_command.issue_list_comments(String(child))
+  );
+  return comments?.some((comment) => comment.body.trim() === decision.trim());
+}
+async function try_edit_body(child, body) {
+  try {
+    await git_gh_command.issue_edit_body(String(child), body);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function restate_size(child, decision) {
+  const line = size_estimate.stated_line(decision);
+  if (line === void 0) return true;
+  const subject = await epic_read.read_subject(child);
+  if (subject === void 0) return false;
+  const body = subject.body ?? "";
+  const restated = size_estimate.restated(body, line);
+  return restated === body || await try_edit_body(child, restated);
+}
+async function record_on_child(child, decision) {
+  const has_record = await has_comment(child, decision);
+  if (has_record === void 0) return false;
+  const is_commented = has_record || await git_gh_command.issue_try_comment(String(child), decision);
+  if (!is_commented || !await restate_size(child, decision)) return false;
+  return await git_gh_command.issue_clear_label(String(child), NEEDS_DECISION_LABEL);
+}
+function format_child_report(total, failures) {
+  if (failures === 0) return epic_decision.format_decision_report({ total, failures });
+  return `\u26A0\uFE0F  ${String(failures)} of ${String(total)} child issue(s) could not be given the comment or lose \`${NEEDS_DECISION_LABEL}\`; rerun the same command \u2014 nothing is written twice.`;
+}
+async function decide(input) {
+  const epic = await read_decision_target(input);
+  if ("error" in epic) {
+    console.error(`\u2716 ${epic.error}`);
+    return FAILURE_EXIT_CODE;
+  }
+  console.info(await record_on_epic(epic, input.decision));
+  const recorded = await Promise.all(
+    input.children.map(async (child) => await record_on_child(child, input.decision))
+  );
+  const failures = recorded.filter((is_recorded) => !is_recorded).length;
+  console.info(format_child_report(input.children.length, failures));
+  return failures === 0 ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+var epic_decide = {
+  decide
+};
+
+// scripts/epic/epic-remove-plan.ts
+var MINIMUM_PATH_LENGTH = 2;
+function to_path_links(path) {
+  return chain_links(path);
+}
+function find_path_error(path) {
+  if (path.length < MINIMUM_PATH_LENGTH) {
+    return "Two issue numbers are required after the epic: the order to remove is `<M> <N>`, and a longer list removes each consecutive pair.";
+  }
+  return to_path_links(path).length === path.length - 1 ? void 0 : "The path names the same issue twice in a row, which declares no order.";
+}
+function find_undeclared_error(links, chains) {
+  const declared = new Set(epic_chains.links_of(chains).map((link) => format_dependency_link(link)));
+  const missing = links.filter((link) => !declared.has(format_dependency_link(link)));
+  return missing.length === 0 ? void 0 : `The declared dependency order does not name ${format_dependency_links(missing)}; there is nothing to remove.`;
+}
+function find_decision_error(decision) {
+  return decision === void 0 ? void 0 : epic_decision.find_decision_error(decision);
+}
+function find_input_error(input, tracked, chains) {
+  return epic_shape.find_subject_error(input, tracked) ?? find_path_error(input.path) ?? find_undeclared_error(to_path_links(input.path), chains) ?? find_decision_error(input.decision);
+}
+function to_ends(links) {
+  return [...new Set(links.flatMap((link) => [link.blocker, link.blocked]))];
+}
+function to_body(input, chains_after) {
+  return epic_add_body.rewrite_body({
+    body: input.body ?? "",
+    placed: [],
+    chains_after,
+    decision: input.decision,
+    does_clear_declaration: true
+  });
+}
+function build_removal_plan(input) {
+  const tracked = epic_parse.parse_task_list_issue_numbers(input.body);
+  const chains_before = epic_parse.parse_dependency_chains(input.body);
+  const error = find_input_error(input, tracked, chains_before);
+  if (error !== void 0) return { error };
+  const links = to_path_links(input.path);
+  const chains_after = epic_chains.remove_links(chains_before, links);
+  const rewritten = to_body(input, chains_after);
+  if ("error" in rewritten) return { error: rewritten.error };
+  return {
+    plan: {
+      body: rewritten.body,
+      links,
+      // Only the links a relation actually backs: asking `gh` to remove one that was never
+      // recorded is reported as a failure the user cannot act on.
+      removed: epic_graph.recorded_relations(links, input.recorded, input.repo),
+      ends: to_ends(links)
+    }
+  };
+}
+var epic_remove_plan = {
+  build_removal_plan
+};
+
+// scripts/epic/epic-remove.ts
+var FAILURE_EXIT_CODE2 = 1;
+var SUCCESS_EXIT_CODE2 = 0;
+async function comment_decision(ends, decision) {
+  const posted = await Promise.all(
+    ends.map(async (end) => await git_gh_command.issue_try_comment(String(end), decision))
+  );
+  console.info(
+    epic_decision.format_decision_report({
+      total: ends.length,
+      failures: posted.filter((is_posted) => !is_posted).length
+    })
+  );
+}
+function report_relations(plan, failures) {
+  if (plan.removed.length === 0) return;
+  console.info(
+    epic_relations.format_relation_report({ links: plan.removed, failures, action: "drop" })
+  );
+}
+async function write_plan(epic_number, plan, decision) {
+  await git_gh_command.issue_edit_body(String(epic_number), plan.body);
+  console.info(
+    session_cite.text(
+      `\u{1F4CB} Removed ${format_dependency_links(plan.links)} from epic ${session_cite.issue(epic_number)}.`
+    )
+  );
+  report_relations(plan, await epic_relations.apply_relations(plan.removed, "drop"));
+  if (decision !== void 0) await comment_decision(plan.ends, decision);
+}
+async function remove_order(input) {
+  const epic = await epic_read.read_epic(input.epic_number);
+  if ("error" in epic) {
+    console.error(`\u2716 ${epic.error}`);
+    return FAILURE_EXIT_CODE2;
+  }
+  const outcome = epic_remove_plan.build_removal_plan({
+    epic_number: input.epic_number,
+    body: epic.subject.body,
+    labels: epic.subject.labels,
+    path: input.path,
+    recorded: epic.recorded,
+    repo: epic.repo,
+    decision: input.decision
+  });
+  if ("error" in outcome) {
+    console.error(`\u2716 ${outcome.error}`);
+    return FAILURE_EXIT_CODE2;
+  }
+  await write_plan(input.epic_number, outcome.plan, input.decision);
+  return SUCCESS_EXIT_CODE2;
+}
+var epic_remove = {
+  remove_order
+};
+
+export {
+  epic_decide,
+  epic_remove
+};

package/dist/commands/chunk-AQCVEQSM.js

@@ -0,0 +1,99 @@
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+
+// scripts/rules/rule-value-cache.ts
+import { spawn } from "node:child_process";
+import { statSync } from "node:fs";
+import path from "node:path";
+var FALLBACK_DIRECTORY = ["node_modules", ".cache", "josh"];
+var CACHE_FILE = "rule-value.txt";
+var STAMP_FILE = "rule-value.stamp";
+var REFRESH_MINUTES = 15;
+var REFRESH_MS = REFRESH_MINUTES * MS_PER_MINUTE;
+var REFRESH_ARGV = ["josh", "rule:value", "--refresh"];
+var PNPM = "pnpm";
+function cache_path(cwd, file) {
+  const common = git_common_directory.repository(cwd);
+  if (common === void 0) return path.join(cwd, ...FALLBACK_DIRECTORY, file);
+  return path.join(common, git_common_directory.STATE_DIRECTORY, file);
+}
+function read_cached(cwd) {
+  return file_reader.read_if_readable(cache_path(cwd, CACHE_FILE));
+}
+function taken_at_if_fresh(cwd, now_ms) {
+  try {
+    const { mtime } = statSync(cache_path(cwd, CACHE_FILE));
+    return now_ms - mtime.getTime() < REFRESH_MS ? mtime : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function read_fresh(cwd = process.cwd(), now_ms = Date.now()) {
+  const taken_at = taken_at_if_fresh(cwd, now_ms);
+  if (taken_at === void 0) return void 0;
+  const text = read_cached(cwd);
+  return text === void 0 ? void 0 : { text, taken_at };
+}
+function is_refresh_due(cwd, now_ms) {
+  try {
+    return now_ms - statSync(cache_path(cwd, STAMP_FILE)).mtimeMs >= REFRESH_MS;
+  } catch {
+    return true;
+  }
+}
+function write_cache_file(cwd, file, text) {
+  atomic_write.replace_file(cache_path(cwd, file), text);
+}
+function ignore_spawn_error() {
+}
+function start_refresh_default(cwd) {
+  const child = spawn(PNPM, REFRESH_ARGV, { cwd, detached: true, stdio: "ignore" });
+  child.on("error", ignore_spawn_error);
+  child.unref();
+}
+var DEFAULT_PORTS = { now: Date.now, start_refresh: start_refresh_default };
+function is_linked_work_tree(cwd) {
+  return git_common_directory.resolve(cwd) !== void 0;
+}
+function refresh_if_due(cwd, ports) {
+  if (is_linked_work_tree(cwd) || !is_refresh_due(cwd, ports.now())) return;
+  write_cache_file(cwd, STAMP_FILE, new Date(ports.now()).toISOString());
+  ports.start_refresh(cwd);
+}
+function emit(cwd = process.cwd(), ports = DEFAULT_PORTS) {
+  const cached = read_cached(cwd);
+  if (cached !== void 0) process.stderr.write(cached);
+  try {
+    refresh_if_due(cwd, ports);
+  } catch {
+  }
+}
+function store(text, cwd = process.cwd()) {
+  if (is_linked_work_tree(cwd)) return;
+  write_cache_file(cwd, CACHE_FILE, `${text}
+`);
+}
+var rule_value_cache = {
+  CACHE_FILE,
+  REFRESH_MS,
+  STAMP_FILE,
+  cache_path,
+  emit,
+  is_linked_work_tree,
+  read_fresh,
+  store
+};
+
+export {
+  rule_value_cache
+};