@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-PF2HZHJG.js

@@ -0,0 +1,94 @@
+import {
+  lane_sinks
+} from "./chunk-VXWGPQJX.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/lane/lane-stats-request.ts
+var STATS_OPTIONS = {
+  period: { type: "string" },
+  since: { type: "string" },
+  limit: { type: "string" },
+  sinks: { type: "boolean" },
+  over: { type: "string" },
+  why: { type: "string" },
+  pairs: { type: "boolean" },
+  all: { type: "boolean" }
+};
+function positive(text) {
+  const value = Number(text);
+  return text !== void 0 && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function since_of(text = "") {
+  const since_ms = Date.parse(text);
+  return Number.isNaN(since_ms) ? void 0 : since_ms;
+}
+function since_start(text) {
+  const since_ms = since_of(text);
+  return since_ms === void 0 ? void 0 : { since_ms };
+}
+function start_of(values) {
+  if (values.since !== void 0) {
+    return values.period === void 0 ? since_start(values.since) : void 0;
+  }
+  const period_days = positive(values.period);
+  return period_days === void 0 ? void 0 : { period_days };
+}
+function sink_threshold(limit, positionals) {
+  const [given, ...more] = positionals;
+  if (limit !== void 0) return void 0;
+  if (given === void 0) return lane_sinks.DEFAULT_MINUTES;
+  return more.length === 0 ? positive(given) : void 0;
+}
+function sink_choice(values, positionals) {
+  if (values.sinks === true) {
+    const minutes = sink_threshold(values.limit, positionals);
+    return minutes === void 0 ? void 0 : { minutes };
+  }
+  return positionals.length === 0 ? { minutes: void 0 } : void 0;
+}
+function threshold_choice(text) {
+  if (text === void 0) return { minutes: void 0 };
+  const minutes = positive(text);
+  return minutes === void 0 ? void 0 : { minutes };
+}
+function is_period_only(values) {
+  return values.limit !== void 0 || values.all === true;
+}
+function is_one_table(values) {
+  const selected = [
+    values.sinks === true,
+    values.over !== void 0,
+    values.why !== void 0,
+    values.pairs === true
+  ].filter(Boolean).length;
+  return selected <= 1 && (selected === 0 || !is_period_only(values));
+}
+function table_flags(values, positionals) {
+  const choice = sink_choice(values, positionals);
+  const over = threshold_choice(values.over);
+  const why = threshold_choice(values.why);
+  if (choice === void 0 || over === void 0 || why === void 0 || !is_one_table(values)) {
+    return void 0;
+  }
+  return {
+    sinks: choice.minutes,
+    over: over.minutes,
+    why: why.minutes,
+    is_pairs: values.pairs === true
+  };
+}
+function stats_request(rest) {
+  const parsed = cli_flags.arguments_of(rest, STATS_OPTIONS);
+  if (parsed === void 0) return void 0;
+  const start = start_of(parsed.values);
+  const table = table_flags(parsed.values, parsed.positionals);
+  if (start === void 0 || table === void 0) return void 0;
+  return { start, limit: parsed.values.limit, is_all: parsed.values.all === true, ...table };
+}
+var lane_stats_request = { positive, since_of, stats_request };
+
+export {
+  lane_stats_request
+};

package/dist/commands/chunk-PIAVFPYB.js

@@ -0,0 +1,52 @@
+import {
+  epic_issue
+} from "./chunk-GXXWRH6F.js";
+import {
+  git_gh_issue_read,
+  git_gh_issue_rest
+} from "./chunk-U6SMBYTN.js";
+import {
+  git_gh_etag_read
+} from "./chunk-V6WWW6HX.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+
+// scripts/epic/epic-live.ts
+async function child(number, repo) {
+  const json = await git_gh_issue_read.issue_view_json(
+    String(number),
+    "number,state,labels,body",
+    repo,
+    git_gh_etag_read.read
+  );
+  const parsed = epic_issue.parse_epic_issue(json);
+  if (parsed?.number !== number || !["OPEN", "CLOSED"].includes(parsed.state)) {
+    throw new Error(`Cannot read live issue ${session_cite.issue(number, void 0, repo)}`);
+  }
+  return {
+    number,
+    repo,
+    state: epic_issue.normalize_state(parsed.state),
+    labels: epic_issue.label_names(parsed),
+    body: parsed.body,
+    blocked_by: []
+  };
+}
+async function blockers(number, repo) {
+  const endpoint = git_gh_api_path.blocked_by_api_path(String(number), repo);
+  const json = await git_gh_etag_read.read_listing(
+    `${endpoint}${git_gh_api_path.FULL_PAGE_QUERY}`,
+    git_gh_api_path.FULL_PAGE_SIZE
+  );
+  const listing = git_gh_issue_rest.to_blocked_by(json);
+  return listing.nodes.map((blocker) => git_gh_issue_rest.reference_of_blocker(blocker, repo));
+}
+var epic_live = { child, blockers };
+
+export {
+  epic_live
+};

package/dist/commands/chunk-PLE3MBGO.js

@@ -0,0 +1,85 @@
+import {
+  git_gh_etag_read
+} from "./chunk-V6WWW6HX.js";
+import {
+  IN_PROGRESS_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/epic/epic-label-age.ts
+import { z } from "zod";
+var STALE_MINUTES = 90;
+var TIMELINE_PAGE = 100;
+var LABELED_EVENT = "labeled";
+var UNPARSED_TIMELINE_MESSAGE = "timeline did not parse";
+var label_schema = z.object({ name: z.string() });
+var timeline_schema = z.array(
+  z.object({
+    event: z.string().nullish(),
+    created_at: z.string().nullish(),
+    label: label_schema.nullish()
+  })
+);
+function parse_events(raw) {
+  const events = json_value.parse_array(raw);
+  if (events === void 0) throw new Error(UNPARSED_TIMELINE_MESSAGE);
+  return events;
+}
+async function read_timeline(path) {
+  return parse_events(await git_gh_etag_read.read_listing(path, TIMELINE_PAGE));
+}
+function is_in_progress_labeling(event) {
+  return event.event === LABELED_EVENT && event.label?.name.toLowerCase() === IN_PROGRESS_LABEL;
+}
+async function read_labeled_at(issue, repo) {
+  try {
+    const path = `${git_gh_api_path.issue_api_path(String(issue), repo)}/timeline?per_page=${String(TIMELINE_PAGE)}`;
+    const events = timeline_schema.parse(await read_timeline(path));
+    const at = events.findLast((event) => is_in_progress_labeling(event))?.created_at;
+    return typeof at === "string" ? { kind: "at", at } : { kind: "absent" };
+  } catch {
+    return { kind: "unread" };
+  }
+}
+function minutes_since(at, now) {
+  return Math.floor((now.getTime() - Date.parse(at)) / MS_PER_MINUTE);
+}
+function is_stale(labeled_at, now) {
+  if (labeled_at.kind === "unread") return false;
+  if (labeled_at.kind === "absent") return true;
+  return minutes_since(labeled_at.at, now) > STALE_MINUTES;
+}
+function age_text(labeled_at, now) {
+  if (labeled_at.kind === "unread") return "label age unread";
+  if (labeled_at.kind === "absent") return `${IN_PROGRESS_LABEL} older than the timeline \u2014 stale`;
+  const stale = is_stale(labeled_at, now) ? " \u2014 stale" : "";
+  return `${IN_PROGRESS_LABEL} for ${String(minutes_since(labeled_at.at, now))} min${stale}`;
+}
+async function read_ages(issues, repo, now) {
+  const ages = await Promise.all(
+    issues.map(async (issue) => {
+      const labeled_at = await read_labeled_at(issue, repo);
+      return [issue, age_text(labeled_at, now)];
+    })
+  );
+  return new Map(ages);
+}
+var epic_label_age = {
+  STALE_MINUTES,
+  read_labeled_at,
+  is_stale,
+  age_text,
+  read_ages
+};
+
+export {
+  epic_label_age
+};

package/dist/commands/chunk-PM3YCN46.js

@@ -0,0 +1,39 @@
+import {
+  repository_lock
+} from "./chunk-GC73YEU7.js";
+import {
+  durable_state
+} from "./chunk-JSJS3OT7.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/gh/gh-usage-log.ts
+var USAGE_SUFFIX = ".jsonl";
+var USAGE_CAP = 2e3;
+var LOCK_SUFFIX = ".lock";
+var LOCK_WAIT_MS = 5e3;
+var LINE_SEPARATOR = "\n";
+function target_of(repository) {
+  return durable_state.path(durable_state.PREFIX.GH_USAGE, repository, USAGE_SUFFIX);
+}
+function read_lines(target) {
+  const raw = stamp_file.read_stamp_text(target) ?? "";
+  return raw.split(LINE_SEPARATOR).filter((line) => line !== "");
+}
+function append_held(target, line) {
+  const lines = [...read_lines(target), line].slice(-USAGE_CAP);
+  stamp_file.replace_text_stamp(target, `${lines.join(LINE_SEPARATOR)}${LINE_SEPARATOR}`);
+  return true;
+}
+function append(target, record) {
+  const lock = `${target}${LOCK_SUFFIX}`;
+  const line = JSON.stringify(record);
+  if (repository_lock.with_lock_sync(() => append_held(target, line), lock, LOCK_WAIT_MS)) return;
+  throw new Error(`gh usage log: gave up waiting for the lock at ${lock}`);
+}
+var gh_usage_log = { USAGE_CAP, append, read_lines, target_of };
+
+export {
+  gh_usage_log
+};

package/dist/commands/chunk-PMC2N6JK.js

@@ -0,0 +1,91 @@
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  verification_inputs
+} from "./chunk-HQ5U6OZR.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/review/review-stamps.ts
+var LINT_RELATED_PREFIX = "josh-lint-related-stamp-";
+var TEST_RELATED_PREFIX = "josh-test-related-stamp-";
+var TEST_RELATED_RED_PREFIX = "josh-test-related-red-";
+var E2E_PREFIX = "josh-e2e-stamp-";
+var GATE_PREFIX = "josh-gate-stamp-";
+var IN_FLIGHT_PREFIX = "josh-gate-running-";
+var ROUND_ONE_PREFIX = "josh-review-round1-";
+var ROUND_ONE_CODE_PREFIX = "josh-review-round1-code-";
+var BRIEFED_PREFIX = "josh-review-briefed-";
+var REVIEWED_PREFIX = "josh-review-recorded-";
+function inputs_of(labels) {
+  return () => verification_inputs.fingerprint(labels);
+}
+var gate_stamp = file_map_stamp.create(
+  GATE_PREFIX,
+  PROJECT_ROOT,
+  inputs_of(verification_inputs.DECLARED_LABELS)
+);
+var in_flight_stamp = file_map_stamp.create(IN_FLIGHT_PREFIX, PROJECT_ROOT);
+var round_one_stamp = file_map_stamp.create(ROUND_ONE_PREFIX, PROJECT_ROOT);
+var round_one_code_stamp = file_map_stamp.create(
+  ROUND_ONE_CODE_PREFIX,
+  PROJECT_ROOT
+);
+var briefed_stamp = file_map_stamp.create(BRIEFED_PREFIX, PROJECT_ROOT);
+var reviewed_stamp = file_map_stamp.create(REVIEWED_PREFIX, PROJECT_ROOT);
+var lint_related_stamp = file_map_stamp.create(
+  LINT_RELATED_PREFIX,
+  PROJECT_ROOT,
+  inputs_of([gate_labels.LINT_LABEL])
+);
+var test_related_stamp = file_map_stamp.create(
+  TEST_RELATED_PREFIX,
+  PROJECT_ROOT,
+  inputs_of([gate_labels.UNIT_LABEL])
+);
+var test_related_red_stamp = file_map_stamp.create(
+  TEST_RELATED_RED_PREFIX,
+  PROJECT_ROOT,
+  inputs_of([gate_labels.UNIT_LABEL])
+);
+var e2e_stamp = file_map_stamp.create(E2E_PREFIX, PROJECT_ROOT);
+function clear_round_one_code(target) {
+  try {
+    round_one_code_stamp.remove(target);
+  } catch {
+  }
+}
+function clear_round_one(target, code_target) {
+  try {
+    round_one_stamp.remove(target);
+  } catch {
+  }
+  clear_round_one_code(code_target);
+}
+var review_stamps = {
+  briefed_stamp,
+  clear_round_one,
+  clear_round_one_code,
+  e2e_stamp,
+  GATE_PREFIX,
+  gate_stamp,
+  IN_FLIGHT_PREFIX,
+  in_flight_stamp,
+  lint_related_stamp,
+  ROUND_ONE_CODE_PREFIX,
+  round_one_code_stamp,
+  ROUND_ONE_PREFIX,
+  round_one_stamp,
+  reviewed_stamp,
+  test_related_red_stamp,
+  test_related_stamp
+};
+
+export {
+  review_stamps
+};

package/dist/commands/chunk-PTJ6X3QK.js

@@ -0,0 +1,330 @@
+import {
+  related_scope
+} from "./chunk-QA44M56F.js";
+import {
+  whole_suite_files
+} from "./chunk-4MRBLCDB.js";
+import {
+  import_graph
+} from "./chunk-CVZXDKCV.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/test/test-pinned-reach.ts
+import { existsSync } from "node:fs";
+import path2 from "node:path";
+
+// scripts/test/test-pinned-cache-logic.ts
+import { createHash } from "node:crypto";
+import { z } from "zod";
+var DIGEST_ALGORITHM = "sha256";
+var LINE_BREAK = "\n";
+var VERDICTS = ["red", "green", "no-test", "test-only"];
+var STORED_SCHEMA = z.object({
+  verdict: z.enum(VERDICTS),
+  tests: z.record(z.string(), z.string()),
+  basis: z.string().optional(),
+  related: z.record(z.string(), z.string()).optional()
+});
+var GREEN_SCHEMA = z.object({
+  file: z.string(),
+  old_lines: z.array(z.string()),
+  new_lines: z.array(z.string())
+});
+var CACHE_SCHEMA = z.object({
+  test_contents: z.string(),
+  change: z.string(),
+  entries: z.record(z.string(), STORED_SCHEMA),
+  pruned: z.string().optional(),
+  green: z.array(GREEN_SCHEMA).optional()
+});
+function digest_of(text) {
+  return createHash(DIGEST_ALGORITHM).update(text).digest("hex");
+}
+function hunk_key(hunk, content) {
+  if (hunk.parts !== void 0) {
+    return digest_of(JSON.stringify(hunk.parts.map((part) => hunk_key(part, content))));
+  }
+  const start = hunk.new_start - 1;
+  const lines = content.split(LINE_BREAK).slice(start, start + hunk.new_count);
+  return digest_of(JSON.stringify([hunk.file, hunk.function_name ?? "", hunk.old_lines, lines]));
+}
+function distinct(keys) {
+  return keys.map((key, index) => {
+    const seen = keys.slice(0, index).filter((earlier) => earlier === key).length;
+    return seen === 0 ? key : `${key}:${String(seen)}`;
+  });
+}
+function sorted(names) {
+  return names.toSorted((left, right) => left.localeCompare(right));
+}
+function test_set_of(test_files) {
+  return digest_of(sorted(test_files).join(LINE_BREAK));
+}
+function change_of(commit, paths, digests) {
+  return digest_of(JSON.stringify([commit, sorted(paths).map((file) => [file, digests.get(file)])]));
+}
+function entries_of(text) {
+  return json_value.parse_with(text, CACHE_SCHEMA)?.entries ?? {};
+}
+function greens_of(text) {
+  return json_value.parse_with(text, CACHE_SCHEMA)?.green ?? [];
+}
+function freshness_of(text, now) {
+  const cache = json_value.parse_with(text, CACHE_SCHEMA);
+  return {
+    is_same_change: cache?.change === now.change,
+    is_unchanged: cache?.test_contents === now.test_contents,
+    is_pruned: cache?.pruned !== void 0 && cache.pruned === now.pruned
+  };
+}
+function holds_tests(tests, freshness, digests) {
+  const files = Object.entries(tests);
+  if (files.length === 0) return freshness.is_unchanged;
+  return files.every(([file, digest]) => digests.get(file) === digest);
+}
+function is_based(entry, basis) {
+  return entry.basis !== void 0 && entry.basis === basis;
+}
+function is_same_code(freshness) {
+  return freshness.is_same_change || freshness.is_pruned;
+}
+function holds(entry, freshness, digests, basis) {
+  if (entry.verdict !== "red") return freshness.is_unchanged || is_based(entry, basis);
+  const is_same = is_same_code(freshness) || is_based(entry, basis);
+  return is_same && holds_tests(entry.tests, freshness, digests);
+}
+function fresh_verdict(entry, freshness, digests, basis) {
+  if (entry === void 0 || !holds(entry, freshness, digests, basis)) return void 0;
+  return { verdict: entry.verdict, failed: Object.keys(entry.tests) };
+}
+function related_basis(tests, digests, config) {
+  const pairs = sorted(tests).map((file) => [file, digests.get(file) ?? ""]);
+  return { digest: digest_of(JSON.stringify([config, pairs])), related: Object.fromEntries(pairs) };
+}
+function changed_tests(before, now) {
+  if (Object.keys(before).some((file) => now[file] === void 0)) return void 0;
+  return Object.keys(now).filter((file) => before[file] !== now[file]);
+}
+function recheck_tests(entry, basis) {
+  if (entry.related === void 0 || basis?.related === void 0) return void 0;
+  return changed_tests(entry.related, basis.related);
+}
+function failed_recheck(entry, digests) {
+  const failed = Object.keys(entry.tests);
+  if (failed.length === 0 || failed.some((file) => !digests.has(file))) return void 0;
+  return { verdict: entry.verdict, recheck: failed };
+}
+function recheck_of(entry, freshness, basis, digests) {
+  if (entry.verdict === "red") return failed_recheck(entry, digests);
+  if (!freshness.is_same_change) return void 0;
+  const recheck = recheck_tests(entry, basis) ?? [];
+  return recheck.length === 0 ? void 0 : { verdict: entry.verdict, recheck };
+}
+function rechecked(known, probe) {
+  if (known.verdict !== "red") {
+    return probe.verdict === "no-test" ? { verdict: known.verdict, failed: [] } : probe;
+  }
+  return probe.verdict === "green" || probe.verdict === "no-test" ? void 0 : probe;
+}
+function is_recheck(known) {
+  return known !== void 0 && "recheck" in known;
+}
+function red_basis(assets, closures) {
+  const named = closures.toSorted(([left], [right]) => left.localeCompare(right));
+  return digest_of(JSON.stringify([assets, named]));
+}
+function tests_of(failed, digests) {
+  const pairs = failed.flatMap((file) => {
+    const digest = digests.get(file);
+    return digest === void 0 ? [] : [[file, digest]];
+  });
+  return pairs.length === failed.length ? Object.fromEntries(pairs) : {};
+}
+function stored_of(probe, digests, basis) {
+  const entry = { verdict: probe.verdict, tests: tests_of(probe.failed, digests) };
+  if (basis === void 0) return entry;
+  return basis.related === void 0 ? { ...entry, basis: basis.digest } : { ...entry, basis: basis.digest, related: basis.related };
+}
+function stored(keys, probes, digests, bases = []) {
+  const pairs = keys.flatMap((key, index) => {
+    const probe = probes[index];
+    if (probe === void 0 || probe.verdict === "stopped") return [];
+    return [[key, stored_of(probe, digests, bases[index])]];
+  });
+  return Object.fromEntries(pairs);
+}
+var test_pinned_cache_logic = {
+  change_of,
+  digest_of,
+  distinct,
+  entries_of,
+  fresh_verdict,
+  freshness_of,
+  greens_of,
+  hunk_key,
+  is_recheck,
+  recheck_of,
+  rechecked,
+  red_basis,
+  related_basis,
+  stored,
+  tests_of,
+  test_set_of
+};
+
+// scripts/test/test-pinned-spawn.ts
+import path from "node:path";
+var TOKEN = /[\w.-]+/gu;
+function index_of(universe) {
+  const index = /* @__PURE__ */ new Map();
+  for (const file of universe) {
+    if (test_declared_logic.is_test_file(path.relative(process.cwd(), file))) continue;
+    const name = path.basename(file);
+    index.set(name, [...index.get(name) ?? [], file]);
+  }
+  return index;
+}
+function names_in(text, index) {
+  return (text.match(TOKEN) ?? []).flatMap((token) => index.get(token) ?? []);
+}
+function memoized(read) {
+  const known = /* @__PURE__ */ new Map();
+  return function answer(file) {
+    const found = known.get(file) ?? read(file);
+    known.set(file, found);
+    return found;
+  };
+}
+function reader_of(graph, names_of) {
+  return memoized((file) => [
+    ...new Set([file, ...graph.closure(file)].flatMap((read) => names_of(read)))
+  ]);
+}
+function reverse_of(graph, universe, names_of) {
+  const tests = universe.filter((file) => test_declared_logic.is_test_file(file));
+  return function related(file) {
+    const importers = graph.runtime_importers([file], universe);
+    return tests.filter((test) => names_of(test).some((entry) => importers.has(entry)));
+  };
+}
+function create(graph, universe) {
+  const index = index_of(universe);
+  const names_of = memoized((file) => names_in(graph.strings(file).join(" "), index));
+  const named_from = reader_of(graph, names_of);
+  function started(tests) {
+    const found = /* @__PURE__ */ new Set();
+    const pending = [...tests];
+    for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
+      const next = named_from(current).filter((file) => !found.has(file));
+      for (const file of next) found.add(file);
+      pending.push(...next);
+    }
+    return found;
+  }
+  return { started, related: reverse_of(graph, universe, names_of) };
+}
+var test_pinned_spawn = { create };
+
+// scripts/test/test-pinned-reach.ts
+var NUL = "\0";
+var FIXTURE_MARK = "-fixture";
+async function work_tree_files() {
+  const listed = await git_spawn.read(["ls-files", "-coz", "--exclude-standard"]);
+  return listed.split(NUL).filter((file) => file !== "");
+}
+async function code_universe() {
+  const files = await work_tree_files();
+  const code = files.filter((file) => related_scope.is_relatable(file) && existsSync(file));
+  return code.map((file) => path2.resolve(file));
+}
+async function view_of() {
+  const graph = await import_graph.create(process.cwd());
+  if (graph === void 0) return void 0;
+  const universe = await code_universe();
+  return { graph, universe, spawn: test_pinned_spawn.create(graph, universe) };
+}
+function is_root(view, file) {
+  const relative = path2.relative(process.cwd(), file);
+  if (test_declared_logic.is_test_file(relative)) return false;
+  return view.graph.importers([file], view.universe).size <= 1;
+}
+function is_shared(file) {
+  return !related_scope.is_relatable(file) || whole_suite_files.WHOLE_SUITE_FILES.has(path2.normalize(file));
+}
+function is_asset(view, file) {
+  if (is_shared(file)) return true;
+  const reached = view.graph.runtime_importers([path2.resolve(file)], view.universe);
+  return [...reached].some((reader) => is_root(view, reader));
+}
+function is_fixture(file) {
+  return path2.basename(file).includes(FIXTURE_MARK);
+}
+async function probed_files(files) {
+  if (files.every((file) => !is_fixture(file))) return [...files];
+  const view = await view_of();
+  if (view === void 0) return [...files];
+  return files.filter((file) => !is_fixture(file) || is_asset(view, file));
+}
+function related_of(view, file) {
+  const reached = view.graph.runtime_importers([path2.resolve(file)], view.universe);
+  return [.../* @__PURE__ */ new Set([...reached, ...view.spawn.related(path2.resolve(file))])].map((reader) => path2.relative(process.cwd(), reader)).filter((reader) => test_declared_logic.is_test_file(reader));
+}
+async function reached_test_count(files) {
+  const view = await view_of();
+  if (view === void 0) return void 0;
+  return new Set(files.flatMap((file) => related_of(view, file))).size;
+}
+async function reached_test_counts(files) {
+  const view = await view_of();
+  if (view === void 0) return void 0;
+  return files.map((file) => ({ file, count: related_of(view, file).length }));
+}
+function failed_of(view, tests, inputs) {
+  if (tests.length === 0 || tests.some((test) => !inputs.test_digests.has(test))) return void 0;
+  const started = view.spawn.started(tests.map((test) => path2.resolve(test)));
+  const run = [...tests, ...[...started].map((file) => path2.relative(process.cwd(), file))];
+  const closures = run.map((file) => [file, view.graph.closure_hash(path2.resolve(file))]);
+  const assets = inputs.code.filter((file) => is_shared(file) || started.has(path2.resolve(file)));
+  const change = test_pinned_cache_logic.change_of(inputs.commit, assets, inputs.digests);
+  return test_pinned_cache_logic.red_basis(change, closures);
+}
+function create2(inputs) {
+  const held = {};
+  async function related(file) {
+    held.view ??= view_of();
+    const read = await held.view;
+    return read === void 0 ? void 0 : related_of(read, file);
+  }
+  async function failed(tests) {
+    held.view ??= view_of();
+    const read = await held.view;
+    return read === void 0 ? void 0 : failed_of(read, tests, inputs);
+  }
+  async function spawned(file) {
+    held.view ??= view_of();
+    const read = await held.view;
+    return read?.spawn.related(path2.resolve(file)).map((test) => path2.relative(process.cwd(), test));
+  }
+  return { related, failed, spawned };
+}
+var test_pinned_reach = {
+  code_universe,
+  create: create2,
+  probed_files,
+  reached_test_count,
+  reached_test_counts,
+  work_tree_files
+};
+
+export {
+  test_pinned_cache_logic,
+  test_pinned_reach
+};