@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-RDUFVQVJ.js

@@ -0,0 +1,997 @@
+import {
+  test_related_touched,
+  test_related_verdict
+} from "./chunk-BAEDHPXW.js";
+import {
+  test_related_cap
+} from "./chunk-EE4VOZJP.js";
+import {
+  related_heavy_tests
+} from "./chunk-MNLHYAJO.js";
+import {
+  direct_importers
+} from "./chunk-N4EMFHQ6.js";
+import {
+  test_pinned_reach
+} from "./chunk-ET6IRQ3L.js";
+import {
+  pure_files_entries,
+  related_scope
+} from "./chunk-ZEUKX3RZ.js";
+import {
+  whole_suite_files
+} from "./chunk-WEUUJIWQ.js";
+import {
+  scoped_green
+} from "./chunk-7E43YW53.js";
+import {
+  test_unit_guard
+} from "./chunk-KWLNK2NJ.js";
+import {
+  vitest_failure_summary
+} from "./chunk-GDP7QXYE.js";
+import {
+  since_green
+} from "./chunk-4K7KLR7L.js";
+import {
+  moved_paths
+} from "./chunk-PBAEJ5PT.js";
+import {
+  test_read_map
+} from "./chunk-B2PJEV3S.js";
+import {
+  review_stamps
+} from "./chunk-XSKJAG72.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
+};