@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-A3LCN4KA.js

@@ -1,84 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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

@@ -1,244 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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
-};