@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-JU2MAYQ3.js

@@ -1,997 +0,0 @@
-import {
-  test_related_touched,
-  test_related_verdict
-} from "./chunk-FA7CN75F.js";
-import {
-  test_related_cap
-} from "./chunk-HQZ65PJE.js";
-import {
-  related_heavy_tests
-} from "./chunk-MNLHYAJO.js";
-import {
-  direct_importers
-} from "./chunk-N4EMFHQ6.js";
-import {
-  test_pinned_reach
-} from "./chunk-6FN37DER.js";
-import {
-  pure_files_entries,
-  related_scope
-} from "./chunk-KJPZPTS4.js";
-import {
-  whole_suite_files
-} from "./chunk-WEUUJIWQ.js";
-import {
-  scoped_green
-} from "./chunk-MHF6BDQI.js";
-import {
-  test_unit_guard
-} from "./chunk-KWLNK2NJ.js";
-import {
-  vitest_failure_summary
-} from "./chunk-GDP7QXYE.js";
-import {
-  since_green
-} from "./chunk-6AHAY5VZ.js";
-import {
-  moved_paths
-} from "./chunk-PBAEJ5PT.js";
-import {
-  test_read_map
-} from "./chunk-B2PJEV3S.js";
-import {
-  review_stamps
-} from "./chunk-S5GX3H4P.js";
-import {
-  gate_tree
-} from "./chunk-R36VZIKU.js";
-import {
-  file_map_stamp
-} from "./chunk-M32UPB2D.js";
-import {
-  import_graph
-} from "./chunk-4IDINPBE.js";
-import {
-  input_fingerprint
-} from "./chunk-GA2YSPFH.js";
-import {
-  changed_file_scope
-} from "./chunk-QX2EMUXV.js";
-import {
-  project_checks
-} from "./chunk-RO4QEZJO.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-import {
-  gate_plan
-} from "./chunk-2CKJODCK.js";
-import {
-  core_budget
-} from "./chunk-ZCHZU6NX.js";
-import {
-  repo_discovery
-} from "./chunk-MDKDJF2K.js";
-import {
-  gate_labels
-} from "./chunk-WQ6FS544.js";
-import {
-  lane_ledger_write
-} from "./chunk-KIS7JFNP.js";
-import {
-  lane_paths
-} from "./chunk-G75GWNNY.js";
-import {
-  changed_paths
-} from "./chunk-U5EO4QEV.js";
-import {
-  git_command
-} from "./chunk-IXZZSST7.js";
-import {
-  git_location_environment
-} from "./chunk-B77ZMVHS.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/test/test-related.ts
-import { existsSync as existsSync4 } from "node:fs";
-import path5 from "node:path";
-
-// scripts/test/test-no-base.ts
-import { readFileSync } from "node:fs";
-
-// scripts/git/no-base-checkout.ts
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  rmSync,
-  statSync,
-  symlinkSync,
-  writeFileSync
-} from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { execa } from "execa";
-var CHECKOUT_PREFIX = "josh-no-base-";
-var NODE_MODULES = "node_modules";
-var ORIGIN_URL_KEY = "remote.origin.url";
-async function git(cwd, arguments_) {
-  const { stdout } = await execa("git", arguments_, {
-    cwd,
-    env: git_location_environment.location_free_environment(),
-    extendEnv: true
-  });
-  return stdout.trim();
-}
-function copy_work(root, directory, file) {
-  const source = path.join(root, file);
-  const target = path.join(directory, file);
-  if (!existsSync(source)) {
-    rmSync(target, { force: true });
-    return;
-  }
-  if (statSync(source).isDirectory()) return;
-  mkdirSync(path.dirname(target), { recursive: true });
-  copyFileSync(source, target);
-}
-async function borrow_objects(root, directory) {
-  const common = await git(root, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
-  const alternates = path.join(directory, ".git", "objects", "info", "alternates");
-  writeFileSync(alternates, `${path.join(common, "objects")}
-`);
-}
-async function add_origin(root, directory) {
-  const origin_url = repo_discovery.read_origin_url(root);
-  if (origin_url !== void 0) await git(directory, ["config", ORIGIN_URL_KEY, origin_url]);
-}
-function link_dependencies(root, directory) {
-  const source = path.join(root, NODE_MODULES);
-  if (existsSync(source)) symlinkSync(source, path.join(directory, NODE_MODULES));
-}
-async function check_out(root, directory, head) {
-  await git(directory, ["init", "--quiet"]);
-  await add_origin(root, directory);
-  await borrow_objects(root, directory);
-  await git(directory, ["checkout", "--quiet", "--detach", head]);
-  writeFileSync(path.join(directory, ".git", "shallow"), `${head}
-`);
-}
-async function fill(root, directory) {
-  const head = await git_command.head_commit();
-  await check_out(root, directory, head);
-  link_dependencies(root, directory);
-  const work = await changed_paths.read_changed_since(head);
-  for (const file of work) copy_work(root, directory, file);
-}
-function remove(directory) {
-  rmSync(directory, { force: true, recursive: true });
-}
-async function create(root) {
-  const directory = mkdtempSync(path.join(tmpdir(), CHECKOUT_PREFIX));
-  try {
-    await fill(root, directory);
-  } catch (error) {
-    remove(directory);
-    throw error;
-  }
-  return directory;
-}
-var no_base_checkout = { create, remove };
-
-// scripts/test/test-related-claim.ts
-async function claim_weight(files) {
-  const tests = files === void 0 ? void 0 : await test_pinned_reach.reached_test_count(files);
-  return tests === void 0 ? gate_plan.direct_unit_weight() : gate_plan.scoped_unit_weight(tests);
-}
-async function with_unit_claim(files, run) {
-  if (core_budget.is_covered()) return await run();
-  const weight = await claim_weight(files);
-  return await core_budget.with_command_reservation(weight, run, {
-    memory_mb: gate_plan.unit_memory(weight),
-    command: related_scope.COMMAND_NAME,
-    is_unit: true
-  });
-}
-var test_related_claim = { with_unit_claim };
-
-// scripts/test/test-no-base.ts
-var BASE_ROOTS = /* @__PURE__ */ new Set([
-  "scripts/git/change-base",
-  "scripts/git/git-diff-reads"
-]);
-var BASE_MODULES = /* @__PURE__ */ new Set([
-  ...BASE_ROOTS,
-  "scripts/git/changed-file-scope",
-  "scripts/git/changed-paths",
-  "scripts/git/changed-paths-sync"
-]);
-var TYPE_ONLY_IMPORT = /^import type (?!from )[^"']*["'][^"']*["']/gmu;
-function text_of(file_path) {
-  try {
-    return readFileSync(file_path, "utf8");
-  } catch {
-    return "";
-  }
-}
-function names_any(text, names) {
-  return names.some((name) => text.includes(name));
-}
-function imports_base(source, file, imports) {
-  const runtime = source.replaceAll(TYPE_ONLY_IMPORT, "");
-  return direct_importers.names_any(runtime, file, BASE_ROOTS, imports);
-}
-function touches_base(file, reader) {
-  if (!related_scope.is_relatable(file)) return false;
-  if (BASE_MODULES.has(direct_importers.module_key(file))) return true;
-  const source = reader.read_source(file);
-  return source !== void 0 && imports_base(source, file, reader.imports);
-}
-function touching(root, changed) {
-  const reader = direct_importers.source_reader(root);
-  return changed.filter((file) => touches_base(file, reader));
-}
-async function run_in_checkout(root, files, flags2) {
-  const directory = await no_base_checkout.create(root);
-  try {
-    return await test_unit_guard.run_vitest_in(directory, ["related", ...files, "--run", ...flags2]);
-  } finally {
-    no_base_checkout.remove(directory);
-  }
-}
-async function run_if_touched(root, changed, flags2) {
-  const files = project_checks.is_kit_repository(root) ? touching(root, changed) : [];
-  if (files.length === 0) return 0;
-  process.stdout.write(
-    `josh test:related: ${String(files.length)} changed file(s) touch the base branch's resolution \u2014 their related tests run again in a checkout with no local main, as CI's has none
-`
-  );
-  return await test_related_claim.with_unit_claim(
-    files,
-    async () => await run_in_checkout(root, files, flags2)
-  );
-}
-var test_no_base = { imports_base, names_any, run_if_touched, text_of, touching };
-
-// scripts/test/test-related-synced.ts
-import { existsSync as existsSync2 } from "node:fs";
-import path2 from "node:path";
-var NOTHING_LEFT = { left: [], shared: [], meeting: [] };
-var UNRESOLVED_EXTENSION = ".svelte";
-var FAILURE = {
-  OWN_UNREAD: "the branch's change is not one the graph can vouch for",
-  NOTHING_VOUCHED: "no synced module is one the graph can vouch for",
-  NO_GRAPH: "no import graph could be built",
-  UNRESOLVED: "the work tree holds a file TypeScript does not resolve",
-  THREW: "building or walking the graph failed"
-};
-function failed(failure) {
-  return { ...NOTHING_LEFT, failure };
-}
-function threw(error) {
-  return failed(`${FAILURE.THREW}: ${error instanceof Error ? error.message : String(error)}`);
-}
-function is_unresolved(file) {
-  return path2.extname(file) === UNRESOLVED_EXTENSION;
-}
-function is_beyond_graph(file) {
-  return whole_suite_files.WHOLE_SUITE_FILES.has(path2.normalize(file)) || is_unresolved(file);
-}
-function is_vouched(root, file) {
-  if (!related_scope.is_relatable(file) || is_beyond_graph(file)) return false;
-  return existsSync2(path2.join(root, file));
-}
-function own_of(branch, map) {
-  if (branch === void 0 || map === void 0) return void 0;
-  const data = branch.filter((file) => !related_scope.is_relatable(file));
-  const readers = data.flatMap((file) => test_read_map.readers_of(map, file));
-  const code = branch.filter((file) => related_scope.is_relatable(file));
-  return branch.some((file) => is_beyond_graph(file)) ? void 0 : [...code, ...readers];
-}
-function split_with(graph, inputs) {
-  const { root, main_only, own, universe } = inputs;
-  const from_branch = graph.runtime_importers(own, universe);
-  const meeting = [...graph.runtime_importers(main_only, universe)].filter((file) => from_branch.has(file)).map((file) => path2.relative(root, file));
-  const shared = meeting.filter((file) => test_declared_logic.is_test_file(file));
-  return { left: main_only.map((file) => path2.relative(root, file)), shared, meeting };
-}
-function absolute_in(root, files) {
-  return files.map((file) => path2.join(root, file));
-}
-async function split_by_graph(root, main_only, own) {
-  const graph = await import_graph.create(root);
-  if (graph === void 0) return failed(FAILURE.NO_GRAPH);
-  const universe = await test_pinned_reach.code_universe();
-  const unresolved = universe.find((file) => is_unresolved(file));
-  if (unresolved !== void 0) {
-    return failed(`${FAILURE.UNRESOLVED}: ${path2.relative(root, unresolved)}`);
-  }
-  return split_with(graph, {
-    root,
-    main_only: absolute_in(root, main_only),
-    own: absolute_in(root, own),
-    universe
-  });
-}
-async function split(root, synced, branch, map) {
-  const own = own_of(branch, map);
-  if (own === void 0) return failed(FAILURE.OWN_UNREAD);
-  const main_only = synced.filter((file) => !own.includes(file) && is_vouched(root, file));
-  if (main_only.length === 0) return failed(FAILURE.NOTHING_VOUCHED);
-  try {
-    return await split_by_graph(root, main_only, own);
-  } catch (error) {
-    return threw(error);
-  }
-}
-var test_related_synced = { FAILURE, own_of, split, split_with };
-
-// scripts/test/test-related-moved.ts
-function is_whole_suite(file) {
-  return whole_suite_files.WHOLE_SUITE_FILES.has(file);
-}
-function synced_data(synced, branch) {
-  const data = synced.filter((file) => !related_scope.is_relatable(file) || is_whole_suite(file));
-  return data.filter((file) => !(branch ?? data).includes(file));
-}
-function without_own_tests(since_map, branch) {
-  return since_map.filter(
-    (file) => !test_declared_logic.is_test_file(file) || branch?.includes(file) === false
-  );
-}
-function narrowed_moved(moved, split2, branch, map) {
-  const kept = moved.filter((file) => !split2.left.includes(file));
-  const own = split2.shared.length === 0 ? [] : test_related_synced.own_of(branch, map);
-  return [.../* @__PURE__ */ new Set([...kept, ...own ?? []])];
-}
-function moved_reading(change, parts, branch, split2) {
-  const since_map = [
-    ...without_own_tests(change.since_map ?? [], branch),
-    ...synced_data(parts.synced, branch),
-    ...split2.left
-  ];
-  const changed = [.../* @__PURE__ */ new Set([...change.changed ?? [], ...split2.left])];
-  return { ...change, changed, since_map: [...new Set(since_map)], synced: parts.synced, branch };
-}
-var test_related_moved = { is_whole_suite, moved_reading, narrowed_moved };
-
-// scripts/test/test-related-record.ts
-import { mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import path3 from "node:path";
-
-// scripts/test/unit-count-file.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-import { writeFile } from "node:fs/promises";
-var COUNT_FILE_ENVIRONMENT = "JOSH_UNIT_COUNT_FILE";
-async function write_count(count, target) {
-  if (target === void 0 || target === "") return;
-  try {
-    await writeFile(target, String(count));
-  } catch {
-  }
-}
-function read_count(file) {
-  try {
-    const text = readFileSync2(file, "utf8").trim();
-    const count = Number(text);
-    return text !== "" && Number.isSafeInteger(count) ? count : void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function write_files(files, target) {
-  if (target === void 0 || target === "") return;
-  try {
-    await writeFile(`${target}.files`, JSON.stringify(files));
-  } catch {
-  }
-}
-function read_files(target) {
-  try {
-    const value = json_value.parse_or_undefined(readFileSync2(`${target}.files`, "utf8"));
-    return Array.isArray(value) && value.every((file) => typeof file === "string") ? value : [];
-  } catch {
-    return [];
-  }
-}
-var unit_count_file = { COUNT_FILE_ENVIRONMENT, read_count, read_files, write_count, write_files };
-
-// scripts/test/test-related-record.ts
-var COUNT_FILE_NAME = "count";
-function set_count_target(target) {
-  const { COUNT_FILE_ENVIRONMENT: COUNT_FILE_ENVIRONMENT2 } = unit_count_file;
-  if (target === void 0) Reflect.deleteProperty(process.env, COUNT_FILE_ENVIRONMENT2);
-  else process.env[COUNT_FILE_ENVIRONMENT2] = target;
-}
-function count_directory() {
-  try {
-    return mkdtempSync2(path3.join(tmpdir2(), "josh-test-related-"));
-  } catch {
-    return void 0;
-  }
-}
-async function with_test_count(run) {
-  const directory = count_directory();
-  if (directory === void 0) return { exit_code: await run(), test_files: void 0 };
-  const file = path3.join(directory, COUNT_FILE_NAME);
-  const previous = process.env[unit_count_file.COUNT_FILE_ENVIRONMENT];
-  set_count_target(file);
-  try {
-    const exit_code = await run();
-    return {
-      exit_code,
-      test_files: unit_count_file.read_count(file),
-      passed: unit_count_file.read_files(file)
-    };
-  } finally {
-    set_count_target(previous);
-    rmSync2(directory, { recursive: true, force: true });
-  }
-}
-function readers_of(input, counted) {
-  if (input.scope.mode !== "related") return 0;
-  return input.scope.files.filter((file) => !counted.has(path3.relative(input.root, file))).length;
-}
-function triggers_of(input) {
-  if (input.scope.mode !== "all" || input.scope.files.length === 0) return {};
-  return { trigger_files: input.scope.files.map((file) => path3.relative(input.root, file)) };
-}
-function own_of2(input) {
-  const { changed = [], branch, synced = [], since_map = [] } = input;
-  const joined = /* @__PURE__ */ new Set([...synced, ...since_map]);
-  return changed.filter((file) => branch?.includes(file) ?? !joined.has(file));
-}
-function parts_of(input) {
-  const own = own_of2(input);
-  const rest = (input.changed ?? []).filter((file) => !own.includes(file));
-  return {
-    own,
-    synced: rest.filter((file) => input.synced.includes(file)),
-    since_map: rest.filter(
-      (file) => input.since_map.includes(file) && !input.synced.includes(file)
-    )
-  };
-}
-function reuse_record(reuse) {
-  if (reuse === void 0) return {};
-  return {
-    reused: reuse.reused,
-    reuse_missed: reuse.missed,
-    reuse_reason: reuse.reason,
-    reuse_elapsed_ms: Math.round(reuse.elapsed_ms)
-  };
-}
-function select_record(select_elapsed_ms) {
-  return select_elapsed_ms === void 0 ? {} : { select_elapsed_ms: Math.round(select_elapsed_ms) };
-}
-function over_cap_record(over_cap, own) {
-  if (over_cap === void 0) return {};
-  const hub = test_related_cap.hub_of(over_cap, own);
-  const count = { over_cap: over_cap.length };
-  return hub === void 0 ? count : { ...count, over_cap_hub: hub };
-}
-function branch_parts_record(parts, own) {
-  if (parts === void 0) return {};
-  const branch = /* @__PURE__ */ new Set([...parts.tracked, ...parts.untracked]);
-  const in_branch = own.filter((file) => branch.has(file)).length;
-  return {
-    branch_tracked: parts.tracked.length,
-    branch_untracked: parts.untracked.length,
-    branch_base: parts.base,
-    changed_in_branch: in_branch,
-    changed_off_branch: own.length - in_branch
-  };
-}
-function record_of(input, result) {
-  const { own, synced, since_map } = parts_of(input);
-  const record = {
-    ...reuse_record(input.reuse),
-    ...branch_parts_record(input.branch_parts, own),
-    scope: input.kind ?? related_scope.scope_kind(input.scope),
-    changed: own.length,
-    synced: synced.length,
-    since_map: since_map.length,
-    readers: readers_of(input, /* @__PURE__ */ new Set([...own, ...synced, ...since_map])),
-    ...triggers_of(input),
-    ...over_cap_record(input.over_cap, own),
-    ...select_record(input.select_elapsed_ms),
-    elapsed_ms: Math.round(result.elapsed_ms)
-  };
-  return result.test_files === void 0 ? record : { ...record, test_files: result.test_files };
-}
-async function record_run(input, result, ledger) {
-  const issue = lane_paths.issue_here();
-  await lane_ledger_write.record_test_related({ ...record_of(input, result), issue }, ledger);
-}
-var test_related_record = { own_of: own_of2, record_of, record_run, with_test_count };
-
-// scripts/test/test-related-red.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
-import { stripVTControlCharacters } from "node:util";
-var FAILED_MARK = "failed";
-var OWED_MARK = "no-base";
-var FAILED_FILE_COUNT = /Test Files\s+(?<count>\d+) failed/u;
-function marked(blobs2, mark) {
-  return Object.entries(blobs2).filter(([, value]) => value === mark).map(([file]) => file);
-}
-function reading_of(parts, marks) {
-  return parts === void 0 ? void 0 : { parts, moved: moved_paths.union_of(parts), ...marks };
-}
-function marks_on(before) {
-  const record = review_stamps.test_related_red_stamp.read();
-  if (record === void 0 || !file_map_stamp.describes_base(record, before.base)) return {};
-  return record.blobs ?? {};
-}
-async function read_red(before) {
-  if (before === void 0) return void 0;
-  const blobs2 = marks_on(before);
-  const failed2 = marked(blobs2, FAILED_MARK);
-  if (failed2.length === 0) return void 0;
-  const stamp = review_stamps.test_related_red_stamp;
-  const parts = await since_green.read_moved_parts(stamp, gate_labels.UNIT_LABEL, void 0, before);
-  return reading_of(parts, { failed: failed2, owed: marked(blobs2, OWED_MARK) });
-}
-function green_fallback(fallback) {
-  return review_stamps.test_related_red_stamp.read() === void 0 ? fallback : since_green.FALLBACK.AFTER_RED;
-}
-async function narrowing(red) {
-  if (red !== void 0) return red;
-  const verdict = await since_green.read_verdict(
-    review_stamps.test_related_stamp,
-    gate_labels.UNIT_LABEL
-  );
-  if ("fallback" in verdict) return { fallback: green_fallback(verdict.fallback) };
-  return { parts: verdict.parts, moved: moved_paths.union_of(verdict.parts), failed: [], owed: [] };
-}
-function is_accounted(output, failed2) {
-  const text = stripVTControlCharacters(output);
-  if (text.includes("Unhandled Error")) return false;
-  const groups = FAILED_FILE_COUNT.exec(text)?.groups ?? {};
-  const { count } = groups;
-  return count === String(failed2.length);
-}
-function failed_of(scope, started_ms) {
-  const log = vitest_failure_summary.unit_log_path(related_scope.vitest_arguments(scope));
-  if (!existsSync3(log) || statSync2(log).mtimeMs < started_ms) return [];
-  const { failed_files, failed_tests } = vitest_failure_summary;
-  const output = readFileSync3(log, "utf8");
-  const failed2 = failed_files(failed_tests(output));
-  return is_accounted(output, failed2) ? failed2 : [];
-}
-function blobs_of(failed2, owed) {
-  const entries = [
-    ...owed.map((file) => [file, OWED_MARK]),
-    ...failed2.map((file) => [file, FAILED_MARK])
-  ];
-  return Object.fromEntries(entries);
-}
-function clear() {
-  try {
-    review_stamps.test_related_red_stamp.remove();
-  } catch {
-  }
-}
-function write(before, failed2, owed) {
-  try {
-    review_stamps.test_related_red_stamp.write(
-      before.files,
-      void 0,
-      before.base,
-      blobs_of(failed2, owed)
-    );
-  } catch {
-    clear();
-  }
-}
-function failed_in(run) {
-  return run.first_exit === 0 ? [] : failed_of(run.scope, run.started_ms);
-}
-async function record_red(run) {
-  const { before } = run;
-  if (before === void 0) return;
-  const failed2 = failed_in(run);
-  const is_vouched2 = failed2.length > 0 && scoped_green.is_unmoved(before, await gate_tree.read_gate_tree());
-  if (is_vouched2) write(before, failed2, run.owed);
-  else clear();
-}
-function no_base_files(input) {
-  const joined = /* @__PURE__ */ new Set([...input.since_map, ...input.synced]);
-  const own = (input.changed ?? []).filter((file) => !joined.has(file));
-  return [.../* @__PURE__ */ new Set([...own, ...input.owed])];
-}
-function describe(reading) {
-  const { failed: failed2, moved } = reading;
-  const label = related_scope.COMMAND_LABEL;
-  if (failed2.length === 0) return since_green.describe(label, moved);
-  return `${label}: reading only the ${String(failed2.length)} test file(s) that failed in its last run and the ${String(moved.length)} file(s) changed since.`;
-}
-var test_related_red = { describe, narrowing, no_base_files, read_red, record_red };
-
-// scripts/test/test-related-reuse.ts
-import path4 from "node:path";
-var NO_RECORD = "no-comparable-green";
-function digest_of(graph, file) {
-  const inputs = graph.test_inputs?.(file);
-  return inputs === void 0 ? void 0 : input_fingerprint.of_entries(
-    inputs.toSorted((left, right) => left.localeCompare(right)).map((input) => `${input}:${input_fingerprint.of_file(input)}`)
-  );
-}
-function empty(reason) {
-  return { excluded: [], reused: 0, missed: 0, reason };
-}
-function select(graph, tests, green) {
-  const excluded = tests.filter((file) => {
-    const digest = digest_of(graph, file);
-    return digest !== void 0 && green[file] === digest;
-  });
-  return {
-    excluded,
-    reused: excluded.length,
-    missed: tests.length - excluded.length,
-    reason: "closed-inputs-unchanged"
-  };
-}
-async function select_scope(root, scope) {
-  const recorded = review_stamps.test_related_stamp.read()?.blobs ?? {};
-  if (Object.keys(recorded).length === 0) return empty("no-individual-green");
-  const graph = await import_graph.create(root);
-  if (graph === void 0) return empty("unknown-graph");
-  const universe = await test_pinned_reach.code_universe();
-  const tests = [...graph.runtime_importers(scope.files, universe)].filter(
-    (file) => test_declared_logic.is_test_file(file)
-  );
-  const green = Object.fromEntries(
-    Object.entries(recorded).map(([file, digest]) => [path4.join(root, file), digest])
-  );
-  return select(graph, tests, green);
-}
-async function compare(root, scope, tree) {
-  const parts = await since_green.read_moved_parts(
-    review_stamps.test_related_stamp,
-    gate_labels.UNIT_LABEL,
-    void 0,
-    tree
-  );
-  if (parts === void 0 || parts.synced.length === 0) return empty(NO_RECORD);
-  const moved = moved_paths.union_of(parts);
-  if (moved.some((file) => whole_suite_files.WHOLE_SUITE_FILES.has(file))) {
-    return empty("whole-suite-input");
-  }
-  return await select_scope(root, scope);
-}
-async function blobs(root, files) {
-  if (files.length === 0) return {};
-  try {
-    const graph = await import_graph.create(root);
-    if (graph === void 0) return {};
-    return Object.fromEntries(
-      files.flatMap((file) => {
-        const absolute = path4.resolve(root, file);
-        const digest = digest_of(graph, absolute);
-        return digest === void 0 ? [] : [[path4.relative(root, absolute), digest]];
-      })
-    );
-  } catch {
-    return {};
-  }
-}
-async function read(root, scope, tree) {
-  const started = performance.now();
-  try {
-    const result = tree === void 0 || scope.mode !== "related" ? empty(NO_RECORD) : await compare(root, scope, tree);
-    return { ...result, elapsed_ms: performance.now() - started };
-  } catch {
-    return { ...empty("unreadable-inputs"), elapsed_ms: performance.now() - started };
-  }
-}
-async function retained(root, tree) {
-  const parts = await since_green.read_moved_parts(
-    review_stamps.test_related_stamp,
-    gate_labels.UNIT_LABEL,
-    void 0,
-    tree
-  );
-  if (parts === void 0 || moved_paths.union_of(parts).length > 0) return [];
-  const recorded = review_stamps.test_related_stamp.read()?.blobs ?? {};
-  const current = await blobs(root, Object.keys(recorded));
-  return Object.keys(recorded).filter((file) => current[file] === recorded[file]);
-}
-function flags(reuse) {
-  if (reuse === void 0 || reuse.excluded.length === 0) return [];
-  return ["--passWithNoTests", ...reuse.excluded.flatMap((file) => ["--exclude", file])];
-}
-var test_related_reuse = { blobs, flags, read, retained };
-
-// scripts/test/test-related-run.ts
-function conclusive_tree(before) {
-  if (before === void 0) return void 0;
-  return test_unit_guard.is_running(process.cwd()) ? before : void 0;
-}
-async function run_vitest(scope, args, description) {
-  return await test_related_claim.with_unit_claim(
-    scope.mode === "related" ? scope.files : void 0,
-    async () => await test_unit_guard.run_guarded_vitest(
-      process.cwd(),
-      args,
-      related_scope.COMMAND_NAME,
-      description
-    )
-  );
-}
-async function run_scope(scope, root, command_arguments, reuse) {
-  const description = related_scope.describe_scope(scope, root);
-  if (scope.mode === "none") {
-    process.stdout.write(`${description}
-`);
-    return 0;
-  }
-  const vitest_arguments = related_scope.vitest_arguments(scope, [
-    ...changed_file_scope.flags_of(command_arguments),
-    ...related_heavy_tests.exclude_flags(scope, root),
-    ...test_related_reuse.flags(reuse)
-  ]);
-  return await run_vitest(scope, vitest_arguments, description);
-}
-async function run_and_record(input, command_arguments) {
-  const started = performance.now();
-  const { exit_code, test_files, passed } = await test_related_record.with_test_count(
-    async () => await run_scope(input.scope, input.root, command_arguments, input.reuse)
-  );
-  input.passed = passed ?? [];
-  await test_related_record.record_run(input, {
-    elapsed_ms: performance.now() - started,
-    test_files
-  });
-  return exit_code;
-}
-async function with_no_base_pass(input, command_arguments, exit_code) {
-  if (exit_code !== 0) return exit_code;
-  const flags2 = changed_file_scope.flags_of(command_arguments);
-  return await test_no_base.run_if_touched(input.root, test_related_red.no_base_files(input), flags2);
-}
-function proven_files(input) {
-  return [...input.passed ?? [], ...input.reuse?.excluded ?? []];
-}
-async function record_green(input, tree, exit_code) {
-  if (exit_code !== 0 || tree === void 0) {
-    await scoped_green.record_if_green(review_stamps.test_related_stamp, {
-      before: tree,
-      exit_code
-    });
-    return;
-  }
-  const files = [...proven_files(input), ...await test_related_reuse.retained(input.root, tree)];
-  const blobs2 = await test_related_reuse.blobs(input.root, files);
-  await scoped_green.record_if_green(review_stamps.test_related_stamp, {
-    before: tree,
-    exit_code,
-    ...Object.keys(blobs2).length > 0 && { blobs: blobs2 }
-  });
-}
-async function run_and_vouch(input, command_arguments, before) {
-  const started_ms = Date.now();
-  const first_exit = await run_and_record(input, command_arguments);
-  const exit_code = await with_no_base_pass(input, command_arguments, first_exit);
-  const tree = conclusive_tree(before);
-  await record_green(input, tree, exit_code);
-  await test_related_red.record_red({
-    before: tree,
-    scope: input.scope,
-    first_exit,
-    started_ms,
-    owed: test_related_red.no_base_files(input)
-  });
-  return exit_code;
-}
-var test_related_run = { run_and_record, run_and_vouch };
-
-// scripts/test/test-related-whole.ts
-function is_whole_suite_kept(given, root, environment = process.env) {
-  if (!given.includes(gate_labels.KEEP_WHOLE_SUITE_FLAG)) return false;
-  return lane_paths.lane_issue_of(root, environment) === void 0;
-}
-var test_related_whole = { is_whole_suite_kept };
-
-// scripts/test/test-related.ts
-async function read_or_undefined(read2) {
-  try {
-    return await read2();
-  } catch {
-    return void 0;
-  }
-}
-async function branch_change() {
-  return await read_or_undefined(async () => await changed_paths.read_changed_paths(false));
-}
-async function change_since(root, map) {
-  const since = await read_or_undefined(
-    async () => await changed_paths.read_changed_since(map.commit)
-  );
-  if (since === void 0) return void 0;
-  return test_read_map.changed_since_tree(
-    map,
-    since,
-    input_fingerprint.of_files(root, Object.keys(map.dirty))
-  );
-}
-async function map_change(root, map) {
-  const changed = await change_since(root, map);
-  if (changed === void 0) return { changed: await branch_change(), map: void 0 };
-  const branch = await branch_change();
-  if (branch === void 0) return { changed, map };
-  return { changed, map, since_map: changed.filter((file) => !branch.includes(file)) };
-}
-async function explicit_change(root, explicit, map) {
-  const since = map === void 0 ? void 0 : await change_since(root, map);
-  if (since === void 0) return { changed: explicit, map: void 0 };
-  const named = new Set(explicit);
-  const since_map = since.filter((file) => !named.has(file));
-  return { changed: [...named, ...since_map], map, since_map };
-}
-async function is_green_narrowable(is_whole) {
-  if (!is_whole) return true;
-  return direct_importers.every_test_imports_of(await branch_change() ?? []).length === 0;
-}
-async function since_green_change(root, map, is_whole, red) {
-  const reading = await is_green_narrowable(is_whole) ? await test_related_red.narrowing(red) : { fallback: since_green.FALLBACK.HUB };
-  if ("fallback" in reading) return reading.fallback;
-  const { parts, moved, failed: failed2 } = reading;
-  if (moved.length + failed2.length === 0) return { changed: [], map, is_unmoved: true };
-  const branch = await branch_change();
-  const split2 = await test_related_synced.split(root, parts.synced, branch, map);
-  const change = await explicit_change(
-    root,
-    [...test_related_moved.narrowed_moved(moved, split2, branch, map), ...failed2],
-    map
-  );
-  if (change.map === void 0) return since_green.FALLBACK.NO_READ_MAP;
-  process.stdout.write(`${test_related_red.describe(reading)}
-`);
-  return test_related_moved.moved_reading(change, parts, branch, split2);
-}
-async function whole_change(root, map, is_whole, red) {
-  const since = await since_green_change(root, map, is_whole, red);
-  if (typeof since !== "string") return since;
-  process.stdout.write(`${since_green.fallback_line(gate_labels.UNIT_LABEL, since)}
-`);
-  return map === void 0 ? { changed: await branch_change(), map } : await map_change(root, map);
-}
-function explicit_files(root, command_arguments) {
-  return command_arguments.filter((argument) => !changed_file_scope.is_flag(argument)).map((file) => path5.relative(root, path5.resolve(file)));
-}
-async function read_change(root, command_arguments, is_whole, red) {
-  const map = test_read_map.read_map(root);
-  const explicit = explicit_files(root, command_arguments);
-  return explicit.length > 0 ? await explicit_change(root, explicit, map) : await whole_change(root, map, is_whole, red);
-}
-async function recorded_files(change) {
-  const { changed, map } = change;
-  if (changed === void 0 || map === void 0) return /* @__PURE__ */ new Set();
-  const dirty = new Set(Object.keys(map.dirty));
-  const candidates = changed.filter((file) => !related_scope.is_relatable(file) && !dirty.has(file));
-  return new Set(
-    await read_or_undefined(async () => await changed_paths.read_held_at(map.commit, candidates))
-  );
-}
-function naming_moved(root, change) {
-  const { changed = [], since_map = [], branch = changed } = change;
-  const names = changed.filter((file) => !since_map.includes(file) && branch.includes(file)).map((file) => path5.basename(file));
-  const code = since_map.filter(
-    (file) => related_scope.is_relatable(file) && !test_related_moved.is_whole_suite(file)
-  );
-  return new Set(
-    code.filter(
-      (file) => test_no_base.names_any(test_no_base.text_of(path5.join(root, file)), names)
-    )
-  );
-}
-async function scope_of(root, change, capped) {
-  const recorded = await recorded_files(change);
-  const naming = naming_moved(root, change);
-  const pure_entries = await pure_files_entries.read_moved(root, change.changed);
-  return related_scope.resolve_scope({
-    root,
-    ...change,
-    recorded,
-    naming_moved: naming,
-    pure_entries,
-    every_test_importers: capped.importers,
-    is_present: existsSync4
-  });
-}
-function report_capped(capped, change) {
-  test_related_cap.report_over_cap(capped, test_related_record.own_of(change));
-}
-async function capped_of(root, change, is_whole) {
-  const files = change.is_unmoved === true ? [] : change.changed ?? [];
-  const started_ms = performance.now();
-  const capped = await test_related_cap.capped_importers(root, files, is_whole);
-  const select_elapsed_ms = performance.now() - started_ms;
-  report_capped(capped, change);
-  return { capped, select_elapsed_ms };
-}
-async function reaches_tests(root, paths) {
-  if (paths.length === 0) return false;
-  const change = await explicit_change(root, paths, test_read_map.read_map(root));
-  if (change.map === void 0) return true;
-  const scope = await scope_of(root, change, test_related_cap.NO_CAP);
-  return scope.mode !== "none";
-}
-async function resolve_change(root, change, capped) {
-  const { UNMOVED_REASON } = related_scope;
-  if (change.is_unmoved === true) return { mode: "none", files: [], reason: UNMOVED_REASON };
-  return await scope_of(root, change, capped);
-}
-function owed_of(red) {
-  return red?.owed ?? [];
-}
-async function read_run_input(root, command_arguments, is_whole, before) {
-  const red = await test_related_red.read_red(before);
-  const change = await read_change(root, command_arguments, is_whole, red);
-  const { capped, select_elapsed_ms } = await capped_of(root, change, is_whole);
-  const { changed, synced = [], since_map = [], branch } = change;
-  const scope = await resolve_change(root, change, capped);
-  const reuse = await test_related_reuse.read(root, scope, red === void 0 ? before : void 0);
-  return {
-    scope,
-    root,
-    changed,
-    synced,
-    since_map,
-    branch,
-    owed: owed_of(red),
-    reuse,
-    over_cap: capped.over_cap,
-    select_elapsed_ms
-  };
-}
-function is_narrowed_argument(root, argument, over_cap) {
-  if (direct_importers.is_every_test_import(root, argument)) return true;
-  return over_cap.includes(path5.relative(root, path5.resolve(argument)));
-}
-function report_unhanded(root, command_arguments, input) {
-  const over_cap = input.over_cap ?? [];
-  changed_file_scope.report_unusable_arguments(
-    command_arguments.filter(
-      (argument) => related_scope.is_relatable(argument) && !is_narrowed_argument(root, argument, over_cap)
-    ),
-    input.scope,
-    related_scope.COMMAND_LABEL
-  );
-}
-async function run_touched(given) {
-  const { TOUCHED_FLAG, TOUCHED_KIND } = test_related_touched;
-  const command_arguments = given.filter((argument) => argument !== TOUCHED_FLAG);
-  const root = await changed_file_scope.repository_root_or_cwd();
-  const explicit = explicit_files(root, command_arguments);
-  const changed = explicit.length > 0 ? explicit : await branch_change();
-  const scope = await test_related_touched.read_scope(root, changed);
-  const input = { scope, root, changed, synced: [], since_map: [], kind: TOUCHED_KIND };
-  return await test_related_run.run_and_record(input, command_arguments);
-}
-async function run_fresh(given, tree) {
-  const { KEEP_WHOLE_SUITE_FLAG } = gate_labels;
-  const command_arguments = given.filter((argument) => argument !== KEEP_WHOLE_SUITE_FLAG);
-  const root = await changed_file_scope.repository_root_or_cwd();
-  const before = command_arguments.length === 0 ? tree : void 0;
-  const is_whole = test_related_whole.is_whole_suite_kept(given, root);
-  const input = await read_run_input(root, command_arguments, is_whole, before);
-  const branch_parts = await read_or_undefined(changed_paths.read_changed_parts);
-  report_unhanded(root, command_arguments, input);
-  return await test_related_run.run_and_vouch({ ...input, branch_parts }, command_arguments, before);
-}
-async function run_related_tests(given) {
-  return await test_related_verdict.run(
-    given,
-    async (before) => given.includes(test_related_touched.TOUCHED_FLAG) ? await run_touched(given) : await run_fresh(given, before)
-  );
-}
-var test_related = { reaches_tests, run_related_tests };
-
-export {
-  test_related_synced,
-  test_related
-};