@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-ZB25RO3U.js

@@ -0,0 +1,208 @@
+import {
+  git_gh_blocked_by_graphql
+} from "./chunk-B7UY7EOD.js";
+import {
+  BLOCKED_BY_COUNT_FIELD,
+  BLOCKED_BY_FIELD,
+  ISSUE_FIELDS,
+  PAGE,
+  git_gh_issue_graphql,
+  git_gh_issue_rest,
+  issue_fields_schema,
+  read_blocked_by
+} from "./chunk-U6SMBYTN.js";
+import {
+  git_gh_transport
+} from "./chunk-W4R6ZBLO.js";
+import {
+  git_gh_etag_read
+} from "./chunk-V6WWW6HX.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  GH_SPAWN_CONCURRENCY
+} from "./chunk-NAZ753DE.js";
+import {
+  bounded_pool
+} from "./chunk-EBVS2LKX.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-issue-list-graphql.ts
+import { z } from "zod";
+var LISTING_QUERY = `query($owner: String!, $name: String!, $labels: [String!]) {
+	rateLimit { cost remaining }
+	repository(owner: $owner, name: $name) {
+		issues(${PAGE}, labels: $labels, states: OPEN, orderBy: { field: CREATED_AT, direction: DESC }) {
+			pageInfo { hasNextPage }
+			nodes { ${ISSUE_FIELDS} }
+		}
+	}
+}`;
+var rate_limit_schema = z.object({ cost: z.number(), remaining: z.number() });
+var page_info_schema = z.object({ hasNextPage: z.boolean() });
+var issues_schema = z.object({
+  pageInfo: page_info_schema,
+  nodes: z.array(issue_fields_schema)
+});
+var response_schema = z.looseObject({
+  data: z.looseObject({
+    rateLimit: rate_limit_schema,
+    repository: z.looseObject({ issues: issues_schema })
+  })
+});
+function labels_of(label) {
+  return label === void 0 ? void 0 : [label];
+}
+function to_page(data) {
+  const { issues } = data.repository;
+  return {
+    issues: issues.nodes.map((issue) => ({
+      rest: git_gh_issue_graphql.to_rest_issue(issue),
+      blocked_by: git_gh_issue_graphql.to_blocked_by(issue)
+    })),
+    has_next_page: issues.pageInfo.hasNextPage,
+    cost: data.rateLimit.cost,
+    remaining: data.rateLimit.remaining
+  };
+}
+async function read_open_page(label, repo) {
+  const repository = git_gh_issue_graphql.repository_variables_of(repo);
+  if (repository === void 0) return void 0;
+  const variables = { ...repository, labels: labels_of(label) };
+  const json = await git_gh_transport.query({ query: LISTING_QUERY, variables });
+  if (json === void 0) return void 0;
+  const data = json_value.parse_with(json, response_schema)?.data;
+  return data === void 0 ? void 0 : to_page(data);
+}
+var git_gh_issue_list_graphql = {
+  read_open_page
+};
+
+// scripts/gh/git-gh-issue-list.ts
+var PER_PAGE = 100;
+var FIRST_PAGE = 1;
+var DEFAULT_STATE = "open";
+var DEFAULT_SORT = "created";
+var LISTING_DIRECTION = "direction=desc";
+function listing_query(request) {
+  const state = request.state ?? DEFAULT_STATE;
+  const sort = request.sort ?? DEFAULT_SORT;
+  return `state=${state}&sort=${sort}&${LISTING_DIRECTION}`;
+}
+function listing_path(request, page) {
+  const label = request.label === void 0 ? "" : `&labels=${encodeURIComponent(request.label)}`;
+  const paging = `&per_page=${String(PER_PAGE)}&page=${String(page)}`;
+  return `${git_gh_api_path.issues_api_path(request.repo)}?${listing_query(request)}${label}${paging}`;
+}
+var DIGIT_PATTERN = /\d/u;
+function has_token_occurrence(body, term) {
+  let index = body.indexOf(term);
+  while (index !== -1) {
+    if (!DIGIT_PATTERN.test(body.charAt(index + term.length))) return true;
+    index = body.indexOf(term, index + 1);
+  }
+  return false;
+}
+function matches_body(rest, term) {
+  if (term === void 0) return true;
+  const { body } = rest;
+  return typeof body === "string" && has_token_occurrence(body, term);
+}
+function is_selected(rest, request) {
+  return !git_gh_issue_rest.is_pull_request(rest) && matches_body(rest, request.body_term);
+}
+async function fetch_page(request, page) {
+  const detail = await git_gh_etag_read.read_detail(listing_path(request, page));
+  const rows = git_gh_issue_rest.parse_rest_issues(detail.body);
+  return {
+    selected: rows.filter((row) => is_selected(row, request)),
+    is_full: rows.length >= PER_PAGE,
+    is_unchanged: detail.is_unchanged
+  };
+}
+var MAX_PAGES = 5;
+var MAX_SCANNED = MAX_PAGES * PER_PAGE;
+function wants_more(has_more, selected_count, limit) {
+  return has_more && selected_count < limit;
+}
+async function fetch_selected(request) {
+  const selected = [];
+  const unchanged = [];
+  let has_more = true;
+  while (unchanged.length < MAX_PAGES && wants_more(has_more, selected.length, request.limit)) {
+    const result = await fetch_page(request, FIRST_PAGE + unchanged.length);
+    selected.push(...result.selected);
+    has_more = result.is_full;
+    unchanged.push(result.is_unchanged);
+  }
+  return {
+    rows: selected.slice(0, request.limit),
+    is_capped: wants_more(has_more, selected.length, request.limit),
+    is_unchanged: unchanged.length > 0 && unchanged.every(Boolean)
+  };
+}
+async function read_relations(rows, repo) {
+  const answered = await git_gh_blocked_by_graphql.read_answered(rows);
+  return await bounded_pool.bounded_map(
+    rows,
+    GH_SPAWN_CONCURRENCY,
+    async (row) => answered.get(row) ?? await read_blocked_by(String(row.number), row, repo)
+  );
+}
+var GRAPHQL_FIELDS = /* @__PURE__ */ new Set([
+  "number",
+  "title",
+  "body",
+  "labels",
+  "createdAt",
+  "url",
+  "author_association",
+  "user",
+  BLOCKED_BY_FIELD,
+  BLOCKED_BY_COUNT_FIELD
+]);
+function is_open_newest_first(request) {
+  return (request.state ?? DEFAULT_STATE) === DEFAULT_STATE && (request.sort ?? DEFAULT_SORT) === DEFAULT_SORT;
+}
+function is_graphql_listing(request, fields) {
+  return is_open_newest_first(request) && fields.every((field) => GRAPHQL_FIELDS.has(field));
+}
+async function read_graphql(request, fields) {
+  if (!is_graphql_listing(request, fields)) return void 0;
+  const page = await git_gh_issue_list_graphql.read_open_page(request.label, request.repo);
+  if (page === void 0) return void 0;
+  const selected = page.issues.filter((issue) => is_selected(issue.rest, request));
+  if (wants_more(page.has_next_page, selected.length, request.limit)) return void 0;
+  const rows = selected.slice(0, request.limit).map((issue) => git_gh_issue_rest.to_gh_issue(issue.rest, fields, issue.blocked_by));
+  return { rows, is_capped: false, is_unchanged: false };
+}
+async function read_rest(request, fields) {
+  const { rows, is_capped, is_unchanged } = await fetch_selected(request);
+  const relations = fields.includes(BLOCKED_BY_FIELD) ? await read_relations(rows, request.repo) : void 0;
+  const mapped = rows.map(
+    (row, index) => git_gh_issue_rest.to_gh_issue(row, fields, relations?.[index])
+  );
+  return { rows: mapped, is_capped, is_unchanged };
+}
+async function issue_list(request) {
+  try {
+    const fields = git_gh_issue_rest.split_fields(request.json_fields);
+    const { rows, is_capped, is_unchanged } = await read_graphql(request, fields) ?? await read_rest(request, fields);
+    return { json: JSON.stringify(rows), is_capped, is_unchanged };
+  } catch {
+    return { json: void 0, is_capped: false };
+  }
+}
+var git_gh_issue_list = {
+  issue_list,
+  listing_path
+};
+
+export {
+  FIRST_PAGE,
+  MAX_SCANNED,
+  git_gh_issue_list
+};

package/dist/commands/chunk-ZBRUCKLP.js

@@ -0,0 +1,133 @@
+import {
+  hook_decision
+} from "./chunk-HXAVYXUS.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/lane/lane-investigation-switch.ts
+var INVESTIGATION_ENV_KEY = "JOSH_LANE_INVESTIGATION";
+function is_on() {
+  return hook_decision.is_switch_opt_in(INVESTIGATION_ENV_KEY);
+}
+var lane_investigation_switch = { is_on };
+
+// scripts/run/event/run-event-overrun.ts
+var WITHIN_PATTERN = /^#(?<issue>\d+) net: (?<minutes>\d+) min$/u;
+var SKIPPED_PATTERN = /^#(?<issue>\d+) overrun skipped: (?<reason>.+)$/u;
+var OVERRAN_PATTERN = /^#(?<issue>\d+) overran: (?<minutes>\d+) min net(?:, longest (?<stage>.+?) (?<stage_minutes>\d+) min)? — (?<outcome>.*)$/u;
+var INVESTIGATING_PATTERN = /^investigating in pid (?<pid>\d+)(?: started (?<start>.+))?$/u;
+var ENDED_PATTERN = /^#(?<issue>\d+) overrun: (?<result>.*)$/u;
+var FAILED_PATTERN = /^#(?<issue>\d+) overrun investigation failed: /u;
+var DISABLED_REASON = "disabled (JOSH_LANE_INVESTIGATION is not on)";
+var FILED_RESULT = "filed";
+var NONE_LEAD = "none: ";
+var NOT_REDUCIBLE_LEAD = "; not reducible: ";
+var RECURRED_PATTERN = /^recurred #(?<number>\d+)/u;
+var FOLDED_LEAD = "folded ";
+var FOLDED_SEPARATOR = ",";
+var FOLDED_PATTERN = /^folded (?<list>#\d+(?:,#\d+)*)/u;
+var NUMBER_PATTERN = /#(?<number>\d+)/gu;
+function started_text(issue, minutes, outcome, longest) {
+  const stage = longest === void 0 ? "" : `, longest ${longest.name} ${String(longest.minutes)} min`;
+  return `${issue_cite.plain_for("program", issue)} overran: ${String(minutes)} min net${stage} \u2014 ${outcome}`;
+}
+function within_text(issue, minutes) {
+  return `${issue_cite.plain_for("program", issue)} net: ${String(minutes)} min`;
+}
+function skipped_text(issue, reason) {
+  return `${issue_cite.plain_for("program", issue)} overrun skipped: ${reason}`;
+}
+function investigating(pid, start) {
+  const outcome = `investigating in pid ${String(pid)}`;
+  return start === void 0 ? outcome : `${outcome} started ${start}`;
+}
+function ended_text(issue, result) {
+  return `${issue_cite.plain_for("program", issue)} overrun: ${result}`;
+}
+function failed_text(issue, note) {
+  return `${issue_cite.plain_for("program", issue)} overrun investigation failed: ${note}`;
+}
+function none_result(reason) {
+  return `${NONE_LEAD}${reason}`;
+}
+function recurred_result(issue) {
+  return `recurred ${issue_cite.plain_for("program", issue)}`;
+}
+function recurred_of(result) {
+  const number = RECURRED_PATTERN.exec(result)?.groups?.["number"];
+  return number === void 0 ? void 0 : Number(number);
+}
+function folded_result(issues) {
+  return `${FOLDED_LEAD}${issues.map((issue) => issue_cite.plain_for("program", issue)).join(FOLDED_SEPARATOR)}`;
+}
+function folded_of(result) {
+  const list = FOLDED_PATTERN.exec(result)?.groups?.["list"] ?? "";
+  return [...list.matchAll(NUMBER_PATTERN)].map((match) => Number(match.groups?.["number"]));
+}
+function reason_of(result) {
+  const [lead = ""] = result.split(NOT_REDUCIBLE_LEAD);
+  return lead.startsWith(NONE_LEAD) ? lead.slice(NONE_LEAD.length) : lead;
+}
+function longest_of(groups) {
+  const name = groups["stage"];
+  return name === void 0 ? void 0 : { name, minutes: Number(groups["stage_minutes"]) };
+}
+function overran(groups) {
+  const issue = Number(groups["issue"]);
+  const minutes = Number(groups["minutes"]);
+  const launched = INVESTIGATING_PATTERN.exec(groups["outcome"] ?? "")?.groups;
+  if (launched === void 0) return { kind: "failed", issue, minutes };
+  const pid = Number(launched["pid"]);
+  const longest = longest_of(groups);
+  return { kind: "started", issue, minutes, pid, start: launched["start"], longest };
+}
+function within(groups) {
+  return { kind: "within", issue: Number(groups["issue"]), minutes: Number(groups["minutes"]) };
+}
+function skipped(groups) {
+  return { kind: "skipped", issue: Number(groups["issue"]), reason: groups["reason"] ?? "" };
+}
+function failed(groups) {
+  return { kind: "failed", issue: Number(groups["issue"]), minutes: void 0 };
+}
+function ended(groups) {
+  return { kind: "ended", issue: Number(groups["issue"]), result: groups["result"] ?? "" };
+}
+var READERS = [
+  [WITHIN_PATTERN, within],
+  [SKIPPED_PATTERN, skipped],
+  [OVERRAN_PATTERN, overran],
+  [FAILED_PATTERN, failed],
+  [ENDED_PATTERN, ended]
+];
+function parse(text) {
+  for (const [pattern, read] of READERS) {
+    const groups = pattern.exec(text)?.groups;
+    if (groups !== void 0) return read(groups);
+  }
+  return void 0;
+}
+var run_event_overrun = {
+  DISABLED_REASON,
+  ended_text,
+  failed_text,
+  FILED_RESULT,
+  folded_of,
+  folded_result,
+  investigating,
+  none_result,
+  NOT_REDUCIBLE_LEAD,
+  parse,
+  reason_of,
+  recurred_of,
+  recurred_result,
+  skipped_text,
+  started_text,
+  within_text
+};
+
+export {
+  lane_investigation_switch,
+  run_event_overrun
+};

package/dist/commands/chunk-ZCWBZOBM.js

@@ -0,0 +1,61 @@
+import {
+  reproduction_measure
+} from "./chunk-C2WXQPF3.js";
+import {
+  issue_bug_label
+} from "./chunk-Z4E7V7YJ.js";
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+
+// scripts/issue/defect-origin-line.ts
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var ORIGIN_PREFIX = issue_body_keys.prefix("origin");
+var UNKNOWN_PREFIX = issue_body_keys.line("origin", "unknown");
+var PR_LINE = new RegExp(String.raw`^${ORIGIN_PREFIX} #(?<pr>\d+)$`, "u");
+var UNKNOWN_LINE = new RegExp(`^${UNKNOWN_PREFIX}\uFF08(?<reason>[^\uFF09]*)\uFF09$`, "u");
+var ORIGIN_FORMS = `\`${ORIGIN_PREFIX} #<PR>\` or \`${UNKNOWN_PREFIX}\uFF08<reason>\uFF09\``;
+var MISSING_ORIGIN = `missing origin line: a \`${issue_bug_label.BUG_DECLARATION_LINE}\` body declares ${ORIGIN_FORMS} under ${BACKGROUND_HEADING} (\`pnpm josh defect:origin <N>\` lists candidates)`;
+var MALFORMED_ORIGIN = `malformed origin line: write ${ORIGIN_FORMS} with a non-empty reason`;
+var MISSING_REPRODUCTION = `missing reproduction: a \`${UNKNOWN_PREFIX}\uFF08<reason>\uFF09\` bug carries ${issue_body_keys.heading("reproduction")} with a backticked command and its actual output in a fenced block`;
+function origin_lines(body) {
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join("\n");
+  return markdown_section.unfenced_lines(background).map((line) => line.trim()).filter((line) => line.startsWith(ORIGIN_PREFIX));
+}
+function parse_unknown(line) {
+  const reason = (UNKNOWN_LINE.exec(line)?.groups?.["reason"] ?? "").trim();
+  return reason === "" ? void 0 : { kind: "unknown", reason };
+}
+function parse_line(line) {
+  const pr = PR_LINE.exec(line)?.groups?.["pr"];
+  return pr === void 0 ? parse_unknown(line) : { kind: "pr", pr: Number(pr) };
+}
+function parse(body) {
+  const [first] = origin_lines(body);
+  return first === void 0 ? void 0 : parse_line(first);
+}
+function problem(body) {
+  if (!issue_bug_label.is_bug_fix(body)) return void 0;
+  const lines = origin_lines(body);
+  if (lines.length === 0) return MISSING_ORIGIN;
+  return lines.every((line) => parse_line(line) !== void 0) ? void 0 : MALFORMED_ORIGIN;
+}
+function reproduction_problem(body) {
+  if (!issue_bug_label.is_bug_fix(body) || parse(body)?.kind !== "unknown") return void 0;
+  return reproduction_measure.has_command_output(body) ? void 0 : MISSING_REPRODUCTION;
+}
+var defect_origin_line = {
+  MALFORMED_ORIGIN,
+  MISSING_ORIGIN,
+  MISSING_REPRODUCTION,
+  parse,
+  problem,
+  reproduction_problem
+};
+
+export {
+  defect_origin_line
+};

package/dist/commands/chunk-ZDP6SKBK.js

@@ -0,0 +1,246 @@
+import {
+  run_record_path
+} from "./chunk-WL5JHB3I.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/test/test-read-map.ts
+import { readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import path2 from "node:path";
+
+// scripts/test/test-read-trace.ts
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var RECORD_DIRECTORY_KEY = "JOSH_TEST_READS_DIRECTORY";
+var ROOT_KEY = "JOSH_TEST_READS_ROOT";
+var FILE_URL_PREFIX = "file://";
+var NODE_MODULES = "node_modules";
+var GIT_DIRECTORY = ".git";
+var ROOT_ENTRY = ".";
+var LISTING_READS = /* @__PURE__ */ new Set([
+  "readdir",
+  "readdirSync",
+  "opendir",
+  "opendirSync"
+]);
+var KIND_SUFFIX = { listing: "*", walk: "**" };
+function is_recursive(options) {
+  return typeof options === "object" && options !== null && Reflect.get(options, "recursive") === true;
+}
+function read_kind(name, options) {
+  if (!LISTING_READS.has(name)) return "path";
+  return is_recursive(options) ? "walk" : "listing";
+}
+function read_key(relative, kind) {
+  return kind === "path" ? relative : path.join(relative, KIND_SUFFIX[kind]);
+}
+function script_path(script_name) {
+  if (script_name.startsWith(FILE_URL_PREFIX)) return fileURLToPath(script_name);
+  return path.isAbsolute(script_name) ? script_name : void 0;
+}
+function is_outside(relative) {
+  return relative.startsWith("..") || path.isAbsolute(relative);
+}
+function is_ignored(relative) {
+  const segments = relative.split(path.sep);
+  return segments.includes(NODE_MODULES) || segments[0] === GIT_DIRECTORY;
+}
+function repository_path(root, file_path) {
+  const relative = path.relative(root, file_path);
+  if (relative === "") return ROOT_ENTRY;
+  return is_outside(relative) || is_ignored(relative) ? void 0 : relative;
+}
+function read_target(argument, cwd) {
+  if (typeof argument === "string") return path.resolve(cwd, argument);
+  if (argument instanceof URL) return fileURLToPath(argument);
+  return void 0;
+}
+function frame_reader(query, frame) {
+  const file_path = script_path(frame.script_name);
+  if (file_path === void 0 || file_path === query.recorder) return void 0;
+  const relative = repository_path(query.root, file_path);
+  return relative === ROOT_ENTRY ? void 0 : relative;
+}
+function stack_reader(query) {
+  const outermost = query.frames.findLast((frame) => frame_reader(query, frame) !== void 0);
+  if (outermost?.function_name !== "") return void 0;
+  return frame_reader(query, outermost);
+}
+function add_reader(records, read_path, reader) {
+  const readers = records.get(read_path) ?? /* @__PURE__ */ new Set();
+  readers.add(reader);
+  records.set(read_path, readers);
+}
+function to_records(records) {
+  return Object.fromEntries([...records].map(([read_path, readers]) => [read_path, [...readers]]));
+}
+var test_read_trace = {
+  RECORD_DIRECTORY_KEY,
+  ROOT_ENTRY,
+  ROOT_KEY,
+  add_reader,
+  read_key,
+  read_kind,
+  read_target,
+  repository_path,
+  script_path,
+  stack_reader,
+  to_records
+};
+
+// scripts/test/test-read-map.ts
+var MAP_VERSION = 8;
+var MAP_FILE_STEM = "test-read-map";
+var RECORD_EXTENSION = ".json";
+var STALE_AFTER_MS = 6048e5;
+function record_pairs(record) {
+  return Object.entries(record).flatMap(
+    ([read_path, readers]) => readers.map((reader) => [read_path, reader])
+  );
+}
+function merge_records(records) {
+  const merged = /* @__PURE__ */ new Map();
+  const pairs = records.flatMap((record) => record_pairs(record));
+  for (const [read_path, reader] of pairs) {
+    test_read_trace.add_reader(merged, read_path, reader);
+  }
+  return test_read_trace.to_records(merged);
+}
+function is_object(value) {
+  return typeof value === "object" && value !== null;
+}
+function is_string_array(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function is_read_records(value) {
+  return is_object(value) && Object.values(value).every(is_string_array);
+}
+function is_digest_record(value) {
+  if (!is_object(value) || Array.isArray(value)) return false;
+  return Object.values(value).every((digest) => typeof digest === "string");
+}
+var FIELD_CHECKS = [
+  ["version", (field) => field === MAP_VERSION],
+  ["commit", (field) => typeof field === "string"],
+  ["dirty", is_digest_record],
+  ["change", is_string_array],
+  ["directories", is_string_array],
+  ["readers", is_read_records]
+];
+function is_read_map(value) {
+  if (!is_object(value)) return false;
+  return FIELD_CHECKS.every(([field, is_valid]) => is_valid(Reflect.get(value, field)));
+}
+function changed_since_tree(map, since, current) {
+  const fresh = since.filter((file) => !Object.hasOwn(map.dirty, file));
+  const moved = Object.entries(map.dirty).filter(([file, digest]) => current[file] !== digest).map(([file]) => file);
+  return [.../* @__PURE__ */ new Set([...fresh, ...moved])];
+}
+function parse_map(text) {
+  const value = json_value.parse_or_undefined(text);
+  return is_read_map(value) ? value : void 0;
+}
+function parse_records(text) {
+  const value = json_value.parse_or_undefined(text);
+  return is_read_records(value) ? value : {};
+}
+function directories_above(relative) {
+  const parent = path2.dirname(relative);
+  if (parent === relative) return [];
+  return [parent, ...directories_above(parent)];
+}
+function created_directories(directories, recorded) {
+  return directories.filter(
+    (directory) => directory !== test_read_trace.ROOT_ENTRY && !recorded.has(directory)
+  );
+}
+function lookup_keys(relative, recorded) {
+  if (run_record_path.is_run_record(relative)) return [relative];
+  const directories = directories_above(relative);
+  const created = created_directories(directories, recorded);
+  const listed = [
+    directories[0] ?? test_read_trace.ROOT_ENTRY,
+    ...created.map((directory) => path2.dirname(directory))
+  ];
+  return [
+    relative,
+    ...created,
+    ...listed.map((directory) => test_read_trace.read_key(directory, "listing")),
+    ...directories.map((directory) => test_read_trace.read_key(directory, "walk"))
+  ];
+}
+function readers_of(map, relative) {
+  const keys = lookup_keys(relative, new Set(map.directories));
+  return [...new Set(keys.flatMap((key) => map.readers[key] ?? []))];
+}
+function in_unread_directory(map, relative) {
+  if (run_record_path.is_run_record(relative)) return true;
+  const directory = path2.dirname(relative);
+  const change = new Set(map.change);
+  const keys = Object.keys(map.readers).filter((key) => !change.has(key));
+  return keys.every((key) => path2.dirname(key) !== directory);
+}
+function map_path(root, version = MAP_VERSION) {
+  const common = git_common_directory.repository(root);
+  const name = `${MAP_FILE_STEM}.v${String(version)}${RECORD_EXTENSION}`;
+  return common === void 0 ? void 0 : path2.join(common, git_common_directory.STATE_DIRECTORY, name);
+}
+function is_map_file(name) {
+  return name.startsWith(MAP_FILE_STEM) && name.endsWith(RECORD_EXTENSION);
+}
+function is_stale(file_path, now) {
+  const modified = statSync(file_path, { throwIfNoEntry: false })?.mtimeMs ?? now;
+  return now - modified > STALE_AFTER_MS;
+}
+function prune_stale_maps(directory) {
+  const now = Date.now();
+  const maps = readdirSync(directory).filter((name) => is_map_file(name)).map((name) => path2.join(directory, name));
+  for (const file_path of maps) {
+    if (is_stale(file_path, now)) rmSync(file_path, { force: true });
+  }
+}
+function read_text(file_path) {
+  try {
+    return readFileSync(file_path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function read_map(root) {
+  const file_path = map_path(root);
+  const text = file_path === void 0 ? void 0 : read_text(file_path);
+  return text === void 0 ? void 0 : parse_map(text);
+}
+function write_map(root, map) {
+  const file_path = map_path(root, map.version);
+  if (file_path === void 0) return;
+  atomic_write.replace_file(file_path, JSON.stringify(map));
+  prune_stale_maps(path2.dirname(file_path));
+}
+function collect_records(directory) {
+  return readdirSync(directory).filter((name) => name.endsWith(RECORD_EXTENSION)).map((name) => parse_records(read_text(path2.join(directory, name)) ?? ""));
+}
+var test_read_map = {
+  MAP_VERSION,
+  changed_since_tree,
+  collect_records,
+  in_unread_directory,
+  map_path,
+  merge_records,
+  parse_map,
+  read_map,
+  readers_of,
+  write_map
+};
+
+export {
+  test_read_trace,
+  test_read_map
+};